vérifier l'intégrité des parenthèses dans une formule spéciale

Question

Mon programme doit imprimer un message à l'écran si la formule que l'utilisateur a entrée est bonne pour les termes (vous ne pouvez utiliser que des chiffres et des lettres, vous ne pouvez pas commencer par '(' et comme une formule mathématique, pour chaque crochet ouvert, il doit y avoir un crochet fermé approprié (et au bon endroit).

voici quelques formules que le programme devrait accepter et des empreintes :

Vrai-

• a(aa(a)aaa(aa(a)aa)aa)aaaa
• a(((())))

voici quelques formules que le programme ne devrait pas accepter et des empreintes :

Faux-

• ()()()
• )()()(

mais le programme imprime toujours Faux Merci de votre aide Voici le code : EDIT

    bool IsNumeric(char character)
    {
        return "0123456789".Contains(character);
        // or return Char.IsNumber(character);
    }

    bool IsLetter(char character)
    {
        return "ABCDEFGHIJKLMNOPQRSTUVWXWZabcdefghigjklmnopqrstuvwxyz".Contains(character);

    }

    bool IsRecognized(char character)
    {
        return IsBracket(character) | IsNumeric(character) | IsLetter(character);
    }
    public bool IsValidInput(string input)
    {
        if (String.IsNullOrEmpty(input) || IsBracket(input[0]))
        {
            return false;
        }
        var bracketsCounter = 0;
        for (var i = 0; i < input.Length; i++)
        {
            var character = input[i];
            if (!IsRecognized(character))
            {
                return false;
            }
            if (IsBracket(character))
            {
                if (character == '(')
                    bracketsCounter++;
                if (character == ')')
                    bracketsCounter--;
            }
        }

        if (bracketsCounter > 0)
        {
            return false;
        }

        return bracketsCounter==0;
    }
}
}

Answer 1

Votre algorithme est inutilement complexe - tout ce dont vous avez besoin est une boucle et un compteur.

• Vérifiez le caractère initial pour ( (vous le faites déjà)
• Mettez le compteur à zéro, et parcourez chaque caractère un par un.
• Si le caractère n'est pas une lettre ou une parenthèse, retournez false.
• Si le personnage est une ouverture ( incrémenter le compteur
• Si le caractère est une fermeture ) si le compteur est inférieur à zéro, il retourne false.
• Retourner à true si le compte est égal à zéro après la fin de la boucle ; sinon retour false

Answer 2

Est-ce que le débogage est vraiment difficile ? Cette condition :

((!IsNumeric(st[i])) && (st[i] != '(') && (st[i] != ')')&&((st[i]<'a')||(st[i]>'z')||(st[i]<'A')||(st[i]>'Z')))
    return false;

est manifestement erronée. Il renvoie false para a à chaque fois. Tu ne prends pas en compte le fait que a est supérieure à Z .

EDIT :

Alors, comment puis-je le rendre plus facile à lire ? avez une autre solution pour ce problème ?

Quant au bloc de conditions, utilisez des méthodes ou des fonctions plus petites, par exemple.

bool IsBracket(char character)
{
    return (character == '(' | character == ')');
}

bool IsNumeric(char character)
{
    return "0123456789".Contains(character);
    // or return Char.IsNumber(character);
}

bool IsLetter(char character)
{
    // see why this is NOT prone to fail just because 'a' is greater than 'Z' in C#?
    return (character >= 'a' & character <= 'z') |
        (character >= 'A' & character <= 'Z');

    // or return Regex.IsMatch(character.ToString(), "[a-zA-Z]", RegexOptions.None);
    // or return Char.IsLetter(character);
}

// now you can implement:
bool IsRecognized(char character)
{
    return IsBracket(character) | IsNumeric(character) | IsLetter(character);
}

et ensuite dans votre grande méthode vous pourriez juste utiliser sans risque :

if (!IsRecognized(st[i]))
    return false;

Cela peut sembler excessif pour un exemple aussi trivial, mais c'est une meilleure approche en principe, et certainement plus lisible.

Et après cela, vous pourriez réduire votre code à quelque chose du genre :

    bool IsInputValid(string input)
    {
        if (String.IsNullOrEmpty(input) || IsBracket(input[0]))
        {
            return false;
        }
        var bracketsCounter = 0;
        for (var i = 0; i < input.Length; i++)
        {
            var character = input[i];
            if (!IsRecognized(character))
            {
                return false;
            }
            if (IsBracket(character)) // redundant?
            {
                if (character == '(') // then what?
                if (character == ')') // then what?
            }
            if (bracketsCounter < what?)
            {
                what?
            }
        }
        return bracketsCounter == what?;
    }

( dasblinkenlight de l'algorithme de l'UE)

EDIT 10 avril

Vous vous trompez.

    bool IsNumeric(char character)
    {
        return "0123456789".Contains(character);
        // or return Char.IsNumber(character);
    }

    bool IsLetter(char character)
    {
        return "ABCDEFGHIJKLMNOPQRSTUVWXWZabcdefghigjklmnopqrstuvwxyz".Contains(character);

    }

    bool IsRecognized(char character)
    {
        return IsBracket(character) | IsNumeric(character) | IsLetter(character);
    }
    public bool IsValidInput(string input)
    {
        if (String.IsNullOrEmpty(input) || IsBracket(input[0]))
        {
            return false;
        }
        var bracketsCounter = 0;
        for (var i = 0; i < input.Length; i++)
        {
            var character = input[i];
            if (!IsRecognized(character))
            {
                return false;
            }
            if (IsBracket(character))
            {
                if (character == '(')
                    bracketsCounter++;
                if (character == ')')
                    bracketsCounter--;
            }
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            if (bracketsCounter < 0) // NOT "> 0", and HERE - INSIDE the for loop
            {
                return false;
            }
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        }

        return bracketsCounter==0;
    }
}
}

Au fait, vous avez également fait une erreur dans votre méthode IsLetter : ...UVWXWZ ? Devrait être UVWXYZ