Usando arreglos en cadenas

Se me ocurrió este código, funciona para lo que quiere el profesor. Cuenta espacios, cuenta palabras, realiza una búsqueda de subcadenas y cuenta letras individualmente y le muestra qué letras se utilizan.

Pero necesito convertirlo en un método de matriz en lugar de un ciclo while de 600 líneas. Realmente no tengo ni idea de cómo hacer esto. ¿Alguien podría darme una entrada?

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();

        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;


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


        int[] counterArray = new int[123];
        string myString;
        int wordCounted = 0;
        int result = 0;
        //Prompt user and get value
        Console.Write("Please enter a string: ");
        myString =
        Console.ReadLine();
        //Word count
        for (int i = 1; i < myString.Length; i++)
        {

            if (char.IsWhiteSpace(myString[i - 1]))
            {

                if (char.IsLetterOrDigit(myString[i]) ||
                char.IsPunctuation(myString[i]))
                {

                    wordCounted++;

                }

            }

        }

        if (myString.Length > 2)
        {

            wordCounted++;

        }

        //White space count
        foreach (char countSpace in myString)
        {

            if (char.IsWhiteSpace(countSpace))
            {

                result++;

            }

        }

        //Display words and space count,
        Console.WriteLine("\nWORDS:\t\t{0}", wordCounted);
        Console.WriteLine("SPACES: \t{0}", result);
        for (int x = 0; x < myString.Length; x++)
        {

            int myValue = Convert.ToInt32(myString[x]);
            counterArray[myValue]++;

        }

        //Display uppercase letter count
        Console.WriteLine("\nUPPERCASE LETTERS: ");
        //Counting uppercase letter
        for (int y = 65; y < 91; y++)
        {

            if (counterArray[y] > 0)
            {

                Console.WriteLine("\t\t{0}:  \t{1}", Convert.ToChar(y), counterArray[y]);
            }

        }

        //Display lowercase letter count

        Console.WriteLine("LOWERCASE LETTERS: ");
        //Counting lowercase letter
        for (int z = 97; z < 123; z++)
        {

            if (counterArray[z] > 0)
            {

                Console.WriteLine("\t\t{0}:  \t{1}", Convert.ToChar(z), counterArray[z]);
            }

        }

        int startingPoint = 0;
        int findStringCount = 0;

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

        Console.WriteLine("Press ENTER to exit...");

        Console.ReadLine();
        }

    }

}

preguntado el 11 de junio de 12 a las 19:06

¿Qué quiere decir cuando dice "convertirlo en un método de matriz"? ¿Desea refactorizar su código para usar una matriz en lugar de innumerables variables? -

probablemente podría prescindir de toda la locura si no con un diccionario simple o incluso una matriz de índices (cada índice representa una letra) -

@Ken, la respuesta que publicó no debería tener ninguna relación con su pregunta ahora. Esa respuesta fue rechazada (y con razón), por lo que ahora quiere ampliar su conocimiento. Digo, bien por él. -

@KenWhite: Si miras más de cerca, verás que lo publicó como respuesta a su propia pregunta. Es probable que el OP todavía esté aprendiendo sobre cómo usar mejor el sitio. -

Mi computadora se retrasa cada vez que abre esta pregunta; ¿Soy solo yo o hay demasiadas filas ahí arriba? -

7 Respuestas

Aquí hay una forma de usar el diccionario y Linq. (Editar agregó la operación linq en mayúsculas para completar la AZ para complementar la az):

Dictionary<char, int> myLetters = new Dictionary<char, int>();

Enumerable.Range(0,26)
          .Select( indx => (char)+('a' + indx))
          .Union( Enumerable.Range(0,26)
                            .Select( indx => (char)+('A' + indx)))
          .ToList()
          .ForEach( chr => myLetters.Add( chr, 0));

myLetters['a'] = 2;
myLetters['Z'] = 3;

myLetters.ToList()
         .ForEach( ml => Console.WriteLine("{0} : {1}", ml.Key, ml.Value));

/* Prints out
a : 2
b : 0
c : 0
...
Z : 3
*/

Tenga en cuenta que lo anterior es para fines de aprendizaje, en realidad haría la tarea myLetters con el enumerable de una sola vez, como:

Dictionary<char, int> myLetters =
      Enumerable.Range(0,26)
               .Select( indx => (char)+('a' + indx))
               .Union( Enumerable.Range(0,26)
                                 .Select( indx => (char)+('A' + indx)))
               .ToDictionary (letter => letter, letter => 0);

Respondido el 12 de junio de 12 a las 14:06

La solución ideal sería utilizar un Dictionary<char,int>, pero si la tarea requiere específicamente una matriz, puede utilizar el hecho de que la representación ASCII de los caracteres alfabéticos es una serie. Es decir, A=65, B=66,...,Z=90 y a=97, b=98,...,z=122. Por ejemplo:

var uppercase = new int[26];
var lowercase = new int[26];

if( ch >= 'A' && ch <= 'Z' )
    uppercase[ch-'A']++;

if( ch >= 'a' && ch <= 'z' )
    lowercase[ch-'a']++;

Luego, cuando vaya a imprimirlo, puede convertir los índices para escribir char:

for( var i='A'; i<='Z'; i++ ) {
    Console.WriteLine( (char)i + " = " + uppercase[i-'A'] );
}

Dejaré el resto de la implementación en tus manos.

Respondido el 11 de junio de 12 a las 20:06

Creo que sería más claro si usara caracteres literales en su lugar (son equivalentes al código de caracteres): if(ch >= 'A' && ch <= 'Z') uppercase[ch - 'A']++; - MRAB

Bueno, en mi humilde opinión, la forma más fácil de obtener una variedad de caracteres sería esta:

char[] alphaLower = "abcdefghijklmnopqrstuvwxyz".ToCharArray();
char[] alphaUpper = //same thing as above with uppercase letters;

en este punto puedes hacer tus cálculos dentro de un bucle. Algo como esto:

foreach(char c in alphaLower)
{
    //possibly a nested foreach here to process each character of input against each char in the alphabet?
    //write your calculation to console
}

No me sorprendería ver lo que tienes arriba reescrito en tan solo 20 líneas de código. Publique lo que se le ocurra en su próxima iteración y continuaremos orientándolo en la dirección correcta.

Respondido el 11 de junio de 12 a las 19:06

Podemos foreach una cadena directamente por cierto. - Martheen

Intente usar una tabla hash... donde la clave es la letra, y el valor es la cantidad de veces que ocurre

if (ht.Contains({yourletter})) //incrementa el valor en 1

        if (ht.ContainsKey(letter))
            ht[letter] = Convert.ToInt32(ht[letter]) + 1;
        else
            ht.Add(letter, 1);

Respondido el 11 de junio de 12 a las 19:06

¿Por qué no Dictionary en lugar de Hashtable? - Martheen

@Martheen Estoy acostumbrado a Hashtables ... todavía no he usado mucho los diccionarios, así que no lo pienses primero. - mira

El espacio ASCII es continuo para las letras mayúsculas y para las versalitas, la A mayúscula comienza en el decimal 65. consulte http://www.asciitable.com/ para conocer más detalles.

debe asignar una matriz para todos los caracteres en la parte inferior de la tabla ascii (127) var countingchars = new int[128];

luego recorre los caracteres en la cadena y hace algo como en este ciclo: countingchars[(byte)currentchar]++;

cada vez que encuentre (byte) currentchar == 32, debe incrementar el recuento de palabras

cuando haya pasado por toda la cadena, obtenga espacios de countingchars[32] obtenga mayúsculas de 65 a 90 obtenga letras minúsculas de 97 a 122

Espero que esto sea suficiente.

Te lo dejo a ti por ponerlo bien en c #

Respondido el 11 de junio de 12 a las 19:06

Probablemente eso es lo que quiso decir el maestro, y explicaste lo suficiente, pero no demasiado, para una pregunta de tarea. - martinstoeckli

Espero que esto ayude en el aprendizaje.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace HomeWork
{
    class Alphabets
    {
        static void Main(string[] args)
        {
            string sentence = null;
            string findString = null;
            int numericCount;
            int upperCount;
            int lowerCount;
            int specialCount;
            int countBlankSpace;
            int countWord;
            Console.Write("Please enter a string: ");
            sentence = Console.ReadLine();
            numericCount = Regex.Matches(sentence, @"\d").Count;
            upperCount = Regex.Matches(sentence, @"[A-Z]").Count;
            lowerCount = Regex.Matches(sentence, @"[a-z]").Count;
            specialCount = Regex.Matches(sentence, @"[!""£$%^&*())]").Count;
            countBlankSpace = new Regex(" ").Matches(sentence).Count;
            countWord = Regex.Matches(sentence, @"[\S]+").Count;
            Console.WriteLine("Report on {0}",sentence);
            Console.WriteLine("# of spaces {0}", countBlankSpace);
            Console.WriteLine("# of lower {0}", lowerCount);
            Console.WriteLine("# of upper {0}", upperCount);
            Console.WriteLine("# of word {0}", countWord);
            Console.WriteLine("# of Special Characters {0}", specialCount);
            Console.Write("Please enter a substring:");
            findString = Console.ReadLine();
            Alphabets.findSubString(findString, sentence);
            Console.WriteLine("\nLowercase Letters \n");
            Alphabets.lowerLetters(sentence);
            Console.WriteLine("\nUppercase Letters \n");
            Alphabets.upperLetters(sentence);
            Console.ReadLine();
        }
        public static void lowerLetters(string sentence)
        {
            int[] upper = new int[(int)char.MaxValue];
            // 1.
            // Iterate over each character.
            foreach (char t in sentence)
            {
                // Increment table.
                upper[(int)t]++;
            }

            // 2.
            // Write all letters found.
            for (int i = 0; i < (int)char.MaxValue; i++)
            {
                if (upper[i] > 0 &&
                char.IsLower((char)i))
                {
                    Console.WriteLine("Letter: {0}  = {1}",
                        (char)i,
                        upper[i]);
                }
            }
        }

        public static void upperLetters(string sentence)
        {
            int[] upper = new int[(int)char.MaxValue];
            // 1.
            // Iterate over each character.
            foreach (char t in sentence)
            {
                // Increment table.
                upper[(int)t]++;
            }

            // 2.
            // Write all letters found.
            for (int i = 0; i < (int)char.MaxValue; i++)
            {
                if (upper[i] > 0 &&
                char.IsUpper((char)i))
                {
                    Console.WriteLine("Letter: {0} = {1}",
                        (char)i,
                        upper[i]);
                }
            }
        }

        public static void findSubString(string findString, string sentence)
        {
            int findStringCount = 0;
            int startingPoint = 0;


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

                } while (sentence.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);
        }

    }
}

Respondido el 12 de junio de 12 a las 02:06

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;



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


        int[] counterArray = new int[123];
        string myString;
        int wordCounted = 0;
        int result = 0;



        //Prompt user and get value
        myString = getStringMethod();


        //Word count
        wordCounted = countWordsMethod(myString, wordCounted);




        //White space count
        result = spaceCounterMethod(myString, result);




        //Display words and space count,
        displayCountMethod(counterArray, myString, wordCounted, result);




        //Display uppercase letter count
        displayUpperMethod();



        //Counting uppercase letter
        uppserCaseMethod(counterArray);

        //Display lowercase letter count

        displayLowerMethod();




        //Counting lowercase letter

        lowerCaseMethod(counterArray);



        Console.WriteLine("Press ENTER to exit...");

        Console.ReadLine();
    }

    private static void displayLowerMethod()
    {
        Console.WriteLine("LOWERCASE LETTERS: ");
    }

    private static void displayUpperMethod()
    {
        Console.WriteLine("\nUPPERCASE LETTERS: ");
    }

    private static void lowerCaseMethod(int[] counterArray)
    {
        for (int z = 97; z < 123; z++)
        {

            if (counterArray[z] > 0)
            {

                Console.WriteLine("\t\t{0}:  \t{1}", Convert.ToChar(z),         counterArray[z]);
            }

        }
    }

    private static void upp

Respondido el 14 de junio de 12 a las 09:06

ok, esta es la versión en MÉTODOS, aparentemente más ordenada que usar solo matrices. Obtuve el 100% por ello. :D gracias por la ayuda. Utilicé el botón derecho y la función MÉTODO DE EXTRACCIÓN para hacer esto. - FhunderTuck

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