C# Cuente cada letra mayúscula y cada letra minúscula [cerrado]

Hola pues tengo tarea, el objetivo es contar cuantas palabras hay, espacios hay, mayusculas y minúsculas. Pero lo que me confunde es que la salida tiene que mostrar todas y cada una de las letras AZ az y tener un número al lado que muestre cuántas veces ocurre. Realmente no entiendo esto en absoluto más allá de donde estoy en mi código. Solo estoy tomando esta clase para poder hacer Cisco Networking y así no tener que hacer Cálculo. Nunca voy a programar después de este semestre. Y he estado atrapado en esto durante 4 horas. Cualquier ayuda sería apreciada... incluso si pudiera ayudarme a entender el concepto de cómo hacer esto. gracias.

He conjurado esto

using System;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int countedWords = 0, count = 0;  //Declaring integers to be used 

            Console.WriteLine("Please enter a string\n");
            string inputString = Console.ReadLine();

            countedWords = inputString.Split(' ').Length; //counts words
            Console.WriteLine("\nREPORT FOR: " + inputString + "\n");
            Console.WriteLine("WORDCOUNT: " + countedWords);


            foreach (char c in inputString)  //counts number of uppercase letters
            {
                if (Char.IsUpper(c))
                    count++;
            }

            Console.WriteLine(count);
            Console.ReadLine();
        }
    }
}

preguntado el 22 de mayo de 12 a las 20:05

Bueno, esto no es exactamente Cálculo. :) -

Sí, no planeo hacer NADA relacionado con C# en la industria de TI.

No estoy pidiendo las respuestas en forma de código. solo una explicación en términos LAYMANS que es comprensible para un n00b:

¡Me lo imaginé! Gracias por la aportación. tengo 25/25 -

6 Respuestas

Ya que esto es tarea, te daré una pista.

Dado que desea contar todas las letras posibles, es posible que desee pensar en este problema en términos de agrupamiento en lugar de iterar y contar. Esto se puede manejar a través de Agrupar por.

contestado el 22 de mayo de 12 a las 20:05

Miré su enlace y eso realmente no tiene sentido para mí. Permítanme decir nuevamente que no sé NADA sobre programación y mi maestro es un inútil, tiene una calificación de 1 de 5 en la calificación de mi proff .com - FhunderTuck

Lo que haría es crear una matriz de 26 (o 52) entradas, inicializarlas todas a 0 y cada vez que vea la letra apropiada, incremente el cubo apropiado. Puedes poner esto en el existente foreach.

Para la visualización, simplemente iteraría a través de su matriz e imprimiría la letra que representa y el número de instancias de esa letra.

contestado el 22 de mayo de 12 a las 20:05

He pensado en eso posiblemente, pero tanta codificación. ¿Hay algún método de bucle que pueda lograr lo mismo? - FhunderTuck

Ya tienes el bucle necesario (tu foreach). Solo le gustaría agregar un paso adicional de comparación/incremento dentro de él. - Adam V

Haz una estructura con Alphabet

  1. Alphabet
  2. Contar

Haga listas a partir de él, ListUpper, ListLower, ListSpace, ListOthers. Cargue la lista a medida que encuentre los elementos adecuados y muéstrela cuando haya terminado.

No escribiré el código por ti :)

contestado el 22 de mayo de 12 a las 20:05

Literalmente eso es como chino para mí - FhunderTuck

mi maestro nunca ha mencionado o mostrado Lista... funciones... - FhunderTuck

el chico enseña java y constantemente se queja de enseñar c# - FhunderTuck

Probablemente debería seguir con las matrices. Si estuviera implementando esto por mi cuenta, usaría algo diferente, pero sé cómo son las clases de introducción y prefieren que te quedes con tipos de datos más básicos. - Katie Kilian

Aquí hay un comienzo para ti.

Primero, colocaría cada una de sus declaraciones en una nueva línea y las convertiría en palabras que correspondan a lo que se está utilizando (si es un contador para minúsculas, haga la variable llamada lowerCase_Count, etc.) En mi opinión, ya que generalmente se considera una buena práctica y hace que sea mucho más fácil leer su código y hacer comentarios sobre lo que hace cada variable u objeto.

Luego, si entiendo lo que escribiste correctamente, está buscando este código para mostrar un recuento de cada: letra mayúscula, letra minúscula, espacio (¿esto es solo un espacio en blanco o, etc.?) y palabra. También quiere una lista de cuántas veces aparece cada letra en el texto dado.

lo que tuviste fue un buen comienzo y agregué un poco más a tu bucle foreach como se ve a continuación:

  using System;
using System.IO;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Declaring integers to be used 
            int countedWords = 0;
            int cap_count = 0;
            int lower_count = 0;

            Console.WriteLine("Please enter a string\n");
            string inputString = Console.ReadLine();

            countedWords = inputString.Split(' ').Length; //counts words
            Console.WriteLine("\nREPORT FOR: " + inputString + "\n");
            Console.WriteLine("WORDCOUNT: " + countedWords);


            foreach (char c in inputString)
            {
                //if is upper case add to cap_count
                if (Char.IsUpper(c))
                    cap_count++;
                //if char is a punctuation or white space ignore it else 
                // add as lower case
                else if (!char.IsPunctuation(c) && !char.IsWhiteSpace(c))
                    lower_count++;

            }

            //display results.
            Console.WriteLine("Number of Letters: " + (cap_count + lower_count));
            Console.WriteLine("Number of capital Letters: " + cap_count);
            Console.WriteLine("Number of lower case Letters: " + lower_count);
            Console.WriteLine("Number of spaces: " + (countedWords - 1));


            Console.ReadLine();
        }
    }
}

Este debería ser un buen punto de partida para completar el resto. Espero que esto ayude.

contestado el 23 de mayo de 12 a las 00:05

¿No harían las comas el lower_count incremento ya que no son ni superiores ni separadores? No soy un tipo de C #, pero solo pregunto. - dan w

Ah buena captura. No lo había probado, pero el código anterior debería funcionar. - James213

Muchas gracias, ahora estoy en la escuela y estoy echando un vistazo para ver si puedo entender lo que has hecho. Gracias por la entrada de todos. - FhunderTuck

Aquí hay otra pista: cada carácter de la cadena tiene un valor numérico, a menudo llamado su valor ASCII*. Puede obtener la cadena como una matriz de chars usando str.ToCharArray().

* Una nota para completar, con más detalle de lo que necesita el cartel original. Las cadenas en C# en realidad se almacenan como caracteres Unicode. Pero los primeros 128 caracteres de UTF-8 se asignan a los caracteres ASCII correspondientes, por lo que, en este caso, la diferencia no importa mucho.

contestado el 22 de mayo de 12 a las 20:05

Esta publicación puede ser útil: stackoverflow.com/questions/4648781/… - Katie Kilian

Using system;
Using system.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            int a = 0;
            int b = 0;
            int c = 0;
            int d = 0;
            int e = 0;
            int f = 0;
            int g = 0;
            int h = 0;
            int i = 0;
            int j = 0;
            int k = 0;
            int l = 0;
            int m = 0;
            int n = 0;
            int o = 0;
            int p = 0;
            int q = 0;
            int r = 0;
            int s = 0;
            int t = 0;
            int u = 0;
            int v = 0;
            int w = 0;
            int x = 0;
            int y = 0;
            int z = 0;

            int A = 0;
            int B = 0;
            int C = 0;
            int D = 0;
            int E = 0;
            int F = 0;
            int G = 0;
            int H = 0;
            int I = 0;
            int J = 0;
            int K = 0;
            int L = 0;
            int M = 0;
            int N = 0;
            int O = 0;
            int P = 0;
            int Q = 0;
            int R = 0;
            int S = 0;
            int T = 0;
            int U = 0;
            int V = 0;
            int W = 0;
            int X = 0;
            int Y = 0;
            int Z = 0;
            int readChar = 0;
            int word = 0;
            int lower = 0;
            int upper = 0;
            string inputString ="";
            char ch = ' ';
            string findString = "";
            int space = 0;
            int startingPoint = 0;
            int findStringCount = 0;


            Console.Write("Please enter a string: ");


            do{
                readChar = Console.Read();

                ch = Convert.ToChar(readChar);
                if (ch.Equals(' '))
                {
                    space++;
                }
                else if (Char.IsLower(ch))
                {
                    lower++;
                    if (ch.Equals('a')) 
                    {
                        a++;
                    }
                    else if (ch.Equals('b')) 
                    {
                        b++;
                    }
                    else if (ch.Equals('c')) 
                    {
                        c++;
                    }
                    else if (ch.Equals('d')) 
                    {
                        d++;
                    }
                    else if (ch.Equals('e')) 
                    {
                        e++;
                    }
                    else if (ch.Equals('f')) 
                    {
                        f++;
                    }
                    else if (ch.Equals('g')) 
                    {
                        g++;
                    }
                    else if (ch.Equals('h')) 
                    {
                        h++;
                    }
                    else if (ch.Equals('i')) 
                    {
                        i++;
                    }
                    else if (ch.Equals('j')) 
                    {
                        j++;
                    }
                    else if (ch.Equals('k')) 
                    {
                        k++;
                    }
                   else if (ch.Equals('l')) 
                    {
                        l++;
                    }
                    else if (ch.Equals('m')) 
                    {
                        m++;
                    }
                    else if (ch.Equals('n')) 
                    {
                        n++;
                    }
                    else if (ch.Equals('o')) 
                    {
                        o++;
                    }
                    else if (ch.Equals('p')) 
                    {
                        p++;
                    }
                    else if (ch.Equals('q')) 
                    {
                        q++;
                    }
                    else if (ch.Equals('r')) 
                    {
                        r++;
                    }
                    else if (ch.Equals('s')) 
                    {
                        s++;
                    }
                    else if (ch.Equals('t')) 
                    {
                        t++;
                    }
                    else if (ch.Equals('u')) 
                    {
                        u++;
                    }
                    else if (ch.Equals('v')) 
                    {
                        v++;
                    }
                    else if (ch.Equals('w')) 
                    {
                        w++;
                    }
                    else if (ch.Equals('x')) 
                    {
                        x++;
                    }
                    else if (ch.Equals('y')) 
                    {
                        y++;
                    }
                    else if (ch.Equals('z')) 
                    {
                        z++;
                    }
                }
                else if (Char.IsUpper(ch))

                {
                    upper++;
                    if (ch.Equals('A')) 
                    {
                        A++;
                    }
                    else if (ch.Equals('B')) 
                    {
                        B++;
                    }
                    else if (ch.Equals('C')) 
                    {
                        C++;
                    }
                    else if (ch.Equals('D')) 
                    {
                        D++;
                    }
                    else if (ch.Equals('E')) 
                    {
                       E++;
                    }
                    else if (ch.Equals('F')) 
                    {
                        F++;
                    }
                    else if (ch.Equals('G')) 
                    {
                       G++;
                    }
                    else if (ch.Equals('H')) 
                    {
                        H++;
                    }
                    else if (ch.Equals('I')) 
                    {
                       I++;
                    }
                    else if (ch.Equals('J')) 
                    {
                        J++;
                    }
                    else if (ch.Equals('K')) 
                    {
                        K++;
                    }
                    else if (ch.Equals('L')) 
                    {
                        L++;
                    }
                    else if (ch.Equals('M')) 
                    {
                       M++;
                    }
                    else if (ch.Equals('N')) 
                    {
                        N++;
                    }
                    else if (ch.Equals('O')) 
                    {
                        O++;
                    }
                    else if (ch.Equals('P')) 
                    {
                       P++;
                    }
                    else if (ch.Equals('Q')) 
                    {
                        Q++;
                    }
                    else if (ch.Equals('R')) 
                    {
                        R++;
                    }
                    else if (ch.Equals('S')) 
                    {
                       S++;
                    }
                    else if (ch.Equals('T')) 
                    {
                        T++;
                    }
                    else if (ch.Equals('U')) 
                    {
                        U++;
                    }
                    else if (ch.Equals('V')) 
                    {
                        V++;
                    }
                    else if (ch.Equals('W')) 
                    {
                        W++;
                    }
                    else if (ch.Equals('X')) 
                    {
                        X++;
                    }
                    else if (ch.Equals('Y')) 
                    {
                        Y++;
                    }
                    else if (ch.Equals('Z')) 
                    {
                        Z++;
                    }
                }

                if (((ch.Equals(' ') && (!inputString.EndsWith(" ")))||(ch.Equals('\r') && (!inputString.EndsWith(" "))))&&(inputString!=""))
                {
                    word++;
                }

                inputString = inputString + ch;

            } while (ch != '\r');

            Console.ReadLine();

            Console.WriteLine("Report on {0}",inputString);

            Console.WriteLine("# of spaces {0}",space);
            Console.WriteLine("# of lower {0}", lower);
            Console.WriteLine("# of upper {0}", upper);
            Console.WriteLine("# of word {0}", word);
            Console.WriteLine("UPPERCASE");
            if (A >= 1)
            {
                Console.WriteLine("A = {0}",A);
            }
            if (B >= 1)
            {
                Console.WriteLine("B = {0}",B);
            }
            if (C >= 1)
            {
                Console.WriteLine("C = {0}", C);
            }
            if (D >= 1)
            {
                Console.WriteLine("D = {0}", D);
            }
            if (E >= 1)
            {
                Console.WriteLine("E = {0}", E);
            }
            if (F >= 1)
            {
                Console.WriteLine("F = {0}", F);
            } if (G >= 1)
            {
                Console.WriteLine("G = {0}", G);
            }
            if (H >= 1)
            {
                Console.WriteLine("H = {0}", H);
            }
            if (I >= 1)
            {
                Console.WriteLine("I = {0}", I);
            }
            if (J >= 1)
            {
                Console.WriteLine("J = {0}", J);
            }
            if (K >= 1)
            {
                Console.WriteLine("K = {0}", K);
            }
            if (L >= 1)
            {
                Console.WriteLine("L = {0}", L);
            }
            if (M >= 1)
            {
                Console.WriteLine("M = {0}", M);
            }
           if (N >= 1)
            {
                Console.WriteLine("N = {0}",N);
            }
            if (O >= 1)
            {
                Console.WriteLine("O = {0}",O);
            }
            if (P >= 1)
            {
                Console.WriteLine("P = {0}",P);
            }
            if (Q >= 1)
            {
                Console.WriteLine("Q = {0}",Q);
            }
            if (R >= 1)
            {
                Console.WriteLine("R = {0}",R);
            }
            if (S >= 1)
            {
                Console.WriteLine("S = {0}",S);
            }
            if (T >= 1)
            {
                Console.WriteLine("T = {0}",T);
            }
            if (U >= 1)
            {
                Console.WriteLine("U = {0}",U);
            }
            if (V >= 1)
            {
                Console.WriteLine("V = {0}",V);
            }
            if (W >= 1)
            {
                Console.WriteLine("W = {0}",W);
            }
            if (X >= 1)
            {
                Console.WriteLine("X = {0}",X);
            }
            if (Y >= 1)
            {
                Console.WriteLine("Y = {0}",Y);
            }
            if (Z >= 1)
            {
                Console.WriteLine("Z = {0}",Z);
            }

            Console.WriteLine("LOWERCASE");
            if (a >= 1)
            {
                Console.WriteLine("a = {0}", a);
            }
            if (b >= 1)
            {
                Console.WriteLine("b = {0}", b);
            }
            if (c >= 1)
            {
                Console.WriteLine("c = {0}", c);
            }
            if (d >= 1)
            {
                Console.WriteLine("d = {0}", d);
            }
            if (e >= 1)
            {
                Console.WriteLine("e = {0}", e);
            }
            if (f >= 1)
            {
                Console.WriteLine("f = {0}", f);
            } if (g >= 1)
            {
                Console.WriteLine("g = {0}", g);
            }
            if (h >= 1)
            {
                Console.WriteLine("h = {0}", h);
            }
            if (i >= 1)
            {
                Console.WriteLine("i = {0}", i);
            }
            if (j >= 1)
            {
                Console.WriteLine("j = {0}", j);
            }
            if (k >= 1)
            {
                Console.WriteLine("k = {0}", k);
            }
            if (l >= 1)
            {
                Console.WriteLine("l = {0}", l);
            }
            if (m >= 1)
            {
                Console.WriteLine("m = {0}", m);
            }
            if (n >= 1)
            {
                Console.WriteLine("n = {0}", n);
            }
            if (o >= 1)
            {
                Console.WriteLine("o = {0}", o);
            }
            if (p >= 1)
            {
                Console.WriteLine("p = {0}", p);
            }
            if (q >= 1)
            {
                Console.WriteLine("q = {0}", q);
            }
            if (r >= 1)
            {
                Console.WriteLine("r = {0}", r);
            }
            if (s >= 1)
            {
                Console.WriteLine("s = {0}", s);
            }
            if (t >= 1)
            {
                Console.WriteLine("t = {0}", t);
            }
            if (u >= 1)
            {
                Console.WriteLine("u = {0}", u);
            }
            if (v >= 1)
            {
                Console.WriteLine("v = {0}", v);
            }
            if (w >= 1)
            {
                Console.WriteLine("w = {0}", w);
            }
            if (x >= 1)
            {
                Console.WriteLine("x = {0}", x);
            }
            if (y >= 1)
            {
                Console.WriteLine("y = {0}", y);
            }
            if (z >= 1)
            {
                Console.WriteLine("z = {0}", z);
            }
            Console.WriteLine();

            Console.Write("Please enter a substring ");
            findString = Console.ReadLine();


            if (findString.Length <= inputString.Length)
            {
                do
                {
                    if (inputString.IndexOf(findString, startingPoint) != -1)
                    {
                        findStringCount++;
                        startingPoint = inputString.IndexOf(findString, startingPoint) + findString.Length;
                    }

                } while (inputString.IndexOf(findString, startingPoint) != -1);
            }
            else
            {
                Console.WriteLine("Substring is too long!");
            }
            Console.WriteLine("The number of times that {0} is found in the text is {1}", findString, findStringCount);

            Console.ReadLine();

        }
    }
}

Respondido 23 Oct 12, 19:10

-1. El peor. Posible. Solución. Casi no hay forma de que pueda elegir una forma menos efectiva. - Ken White

¿Se le paga por línea de código? - Servir

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.