Проверить, является ли символ гласной или согласной?

вот функция, которая работает:

public static class CharacterExtentions
{
    public static bool IsVowel(this char c)
    {
        long x = (long)(char.ToUpper(c)) - 64;
        if (x*x*x*x*x - 51*x*x*x*x + 914*x*x*x - 6894*x*x + 20205*x - 14175 == 0) return true;
        else return false;
    }
}

использовать его как:

char c = 'a';
if (c.IsVowel()) { // it's a Vowel!!! }

(Да, это действительно работает, но, очевидно, это шутка ответ. Не унижай меня. или еще что-нибудь.)

нет. Сначала нужно определить, что вы считаете гласной и согласной. Например, в английском языке " y "может быть согласной (как в" yes") или гласной (как в"by"). Такие буквы, как" é "и" ü", вероятно, являются гласными во всех языках, в которых они используются, но, похоже, вы их вообще не рассматривали. Прежде всего, вы должны определить почему вы хотите, чтобы классифицировать буквы, как согласные и гласные.

Console.WriteLine("Please input a word or phrase:");
string userInput = Console.ReadLine().ToLower();

for (int i = 0; i < userInput.Length; i++)
        {
            //c stores the index of userinput and converts it to string so it is readable and the program wont bomb out.[i]means position of the character.
            string c = userInput[i].ToString();
            if ("aeiou".Contains(c))
            {
                vowelcount++;
            }
        }
        Console.WriteLine(vowelcount);

вы можете использовать "IsVowel", как вы хотели. Однако единственное, что, вероятно, нет библиотеки или функции C# по умолчанию, которая уже делает это из коробки, ну, если это то, что вы хотели. Для этого вам нужно будет написать метод util.

bool a = isVowel('A');//example method call 

public bool isVowel(char charValue){
    char[] vowelList = {'a', 'e', 'i', 'o', 'u'};

    char casedChar = char.ToLower(charValue);//handle simple and capital vowels

    foreach(char vowel in vowelList){
        if(vowel == casedChar){
            return true;
        }
    }

    return false;
}    

Вы можете использовать следующий метод расширения:

using System;
using System.Linq;

public static class CharExtentions
{
    public static bool IsVowel(this char character)
    {
        return new[] {'a', 'e', 'i', 'o', 'u'}.Contains(char.ToLower(character));
    }
}

использовать его как:

'c'.IsVowel(); // Returns false
'a'.IsVowel(); // Returns true

это работает просто отлично.

public static void Main(string[] args)
    {
        int vowelsInString = 0;
        int consonants = 0;
        int lengthOfString;
        char[] vowels = new char[5] { 'a', 'e', 'i', 'o', 'u' };

        string ourString;
        Console.WriteLine("Enter a sentence or a word");
        ourString = Console.ReadLine();
        ourString = ourString.ToLower();

        foreach (char character in ourString)
        {
            for (int i = 0; i < vowels.Length; i++)
            {
                if (vowels[i] == character) 
                {
                    vowelsInString++;
                }
            }
        }
        lengthOfString = ourString.Count(c => !char.IsWhiteSpace(c)); //gets the length of the string without any whitespaces
        consonants = lengthOfString - vowelsInString; //Well, you get the idea.
        Console.WriteLine();
        Console.WriteLine("Vowels in our string: " + vowelsInString);
        Console.WriteLine("Consonants in our string " + consonants);
        Console.ReadKey();
    }
}

другие методы данной работы. Здесь меня интересует производительность. Для двух подходов, которые я тестировал-используя любой метод LINQ и используя битную арифметику, использование битной арифметики было более чем в десять раз быстрее. Результаты:

время для LINQ = 117 МС

время для битовых масок = 8 мс

public static bool IsVowelLinq(char c)
{
    char[] vowels = new[] { 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U' };
    return vowels.Any(ch => ch == c);
}

private static int VowelMask = (1 << 1) | (1 << 5) | (1 << 9) | (1 << 15) | (1 << 21);

public static bool IsVowelBitArithmetic(char c)
{
    // The OR with 0x20 lowercases the letters
    // The test c > 64 rules out punctuation, digits, and control characters.
    // An additional test would be required to eliminate characters above ASCII 127.
    return (c > 64) && ((VowelMask &  (1 << ((c | 0x20) % 32))) != 0);
}

см.https://dotnetfiddle.net/WbPHU4 для кода в тесте с таймингами.

ключевая идея с битовая маска заключается в том, что второй бит установлен для "a", шестой бит установлен для " e " и т. д. Затем вы берете букву, сдвигаете влево ее значение ASCII как целое число и смотрите, установлен ли этот бит в маске. Один бит устанавливается в маске для каждой гласной, и операция или сначала выполняет строчную букву.

Почему бы не создать массив гласных / согласных и не проверить, находится ли значение в массиве?

вы можете сделать что-то вроде этого.

  private bool IsCharacterAVowel(char c)
  {
     string vowels = "aeiou";
     return vowels.IndexOf(c.ToString(),StringComparison.InvariantCultureIgnoreCase) >= 0;      
  }

return "aeiou".Any( c => c.Equals( Char.ToLowerInvariant( myChar ) ) );

попробуйте это:

char[] inputChars = Console.ReadLine().ToCharArray();
int vowels = 0;
int consonants = 0;
foreach (char c in inputChars)
{
   if ("aeiou".Contains(c) || "AEIOU".Contains(c))
   {
       vowels++;
   }
   else
   {
       consonants++;
   }
}
Console.WriteLine("Vowel count: {0} - Consonant count: {1}", vowels, consonants);
Console.ReadKey();

посмотреть этот код для проверки гласных и согласных , с#

private static void Vowel(string value)
{
    int vowel = 0;
    foreach (var x in value.ToLower())
    {
        if (x.Equals('a') || x.Equals('e') || x.Equals('i') || x.Equals('o') || x.Equals('u'))
        {
            vowel += 1;
        }
    } 
    Console.WriteLine( vowel + " number of vowels");
}

private static void Consonant(string value)
{
    int cont = 0;
    foreach (var x in value.ToLower())
    {
        if (x > 'a' && x <= 'd' || x > 'e' && x < 'i' || x > 'j' && x < 'o' || x >= 'p' && x < 'u' || x > 'v' && x < 'z')
        {
            cont += 1;
        }
    }
    Console.WriteLine(cont + " number of consonant");
}