strings_2/Program.cs

using System.Text;

namespace strings_2;

class Program {
    static void Main(string[] args) {
        Menu();
    }

    static void Menu() {
        Console.Clear();
        int scelta;
        string stringa;
        do {
            Console.WriteLine("Inserire un'opzione:");
            Console.WriteLine("1. Verifica parola palindroma");
            Console.WriteLine("2. Verifica frase palindroma");
            Console.WriteLine("3. Conta occorrenze");
            Console.WriteLine("4. Sostituisci lettera");
            Console.WriteLine("5. Prima lettere pari, poi dispari");
            Console.WriteLine("0. Esci");
            Console.Write("Scelta: ");
            scelta = Convert.ToInt32(Console.ReadLine());

            switch (scelta) {
                case 0:
                    break;
                case 1:
                    Console.Clear();
                    Console.Write("Inserire una parola: ");
                    stringa = Console.ReadLine();
                    if (stringa.Contains(' ')) {
                        Console.WriteLine("È consentito inserire solo una parola. Per inserire una frase scegliere l'opzione 2.");
                        Pausa();
                        break;
                    }
                    if (Palindromo(stringa)) {
                        Console.WriteLine("La parola è palindroma");
                    }
                    else {
                        Console.WriteLine("La parola non è palindroma");
                    }
                    Pausa();
                    break;
                case 2:
                    Console.Clear();
                    Console.Write("Inserire una frase: ");
                    if (Palindromo(Console.ReadLine())) {
                        Console.WriteLine("La frase è palindroma");
                    }
                    else {
                        Console.WriteLine("La frase non è palindroma");
                    }
                    Pausa();
                    break;
                case 3:
                    Console.Clear();

                    Console.Clear();
                    break;
                case 4:
                    Console.Clear();

                    Pausa();
                    break;
                case 5:
                    Console.Clear();

                    Pausa();
                    break;
                default:
                    Console.WriteLine("Opzione non valida.");
                    Pausa();
                    break;
            }
        }
        while (scelta != 0);
    }

    static void Pausa() {
        Console.WriteLine("Premere un tasto per continuare. . .");
        Console.ReadKey();
        Console.Clear();
    }

    static char[] InsertionSort(char[] p_array) { //implementazione ufficiale copiata da Classroom
        int i, j;
        char temp;

        for (i = 1; i < p_array.Length; i++) {
            temp = p_array[i];
            j = i - 1;
            while (j >= 0 && p_array[j] > temp) {
                p_array[j + 1] = p_array[j];
                j--;
            }
            p_array[j + 1] = temp;
        }

        return p_array;
    }

    static bool Palindromo(string stringa) {
        bool ritorno;
        char[] metà1, metà2;

        //modifica della stringa per trasformarla in una sequenza di lettere ASCII
        {
            stringa = stringa.ToLower();//convertita in minuscolo per identificare palindromi case insensitive

            //converto la stringa inserita da codifica Unicode a codifica ASCII
            Encoding ascii = Encoding.ASCII;
            Encoding unicode = Encoding.Unicode;
            char[] chars = stringa.ToCharArray();
            byte[] bytes = new byte[chars.Length];

            for (int i = 0; i < chars.Length; i++) {
                bytes[i] = Convert.ToByte(chars[i]);
            }

            Encoding.Convert(unicode, ascii, bytes);

            for (int i = 0; i < chars.Length; i++) {
                chars[i] = Convert.ToChar(bytes[i]);
            }

            //i numeri nei seguenti cicli for sono caratteri non lettere in codifica ASCII e separano i vari blocchi di questi caratteri che contornano i blocchi con le lettere
            //******************************************************************************************************************************************************************************//
            for (int i = 0; i <= 47; i++) {
                stringa = stringa.Replace(Convert.ToString(Convert.ToChar(i)), "");
            }
            for (int i = 58; i < 64; i++) {
                stringa = stringa.Replace(Convert.ToString(Convert.ToChar(i)), "");
            }
            for (int i = 91; i < 96; i++) {
                stringa = stringa.Replace(Convert.ToString(Convert.ToChar(i)), "");
            }
            for (int i = 123; i < 127; i++) {
                stringa = stringa.Replace(Convert.ToString(Convert.ToChar(i)), "");
            }
            //******************************************************************************************************************************************************************************//
        }

        //la divisione serve per escludere la lettera che divide perfettamente a metà la parola con lettere dispari
        if (stringa.Length % 2 == 0) {
            metà1 = stringa.Substring(0, stringa.Length / 2).ToCharArray(); //divido la stringa a metà, prendo la prima e la converto in array di char per riordinarne le lettere
            metà2 = stringa.Substring(stringa.Length / 2, stringa.Length / 2).ToCharArray(); //divido la stringa a metà, prendo la seconda e la converto in array di char per riordinarne le lettere
        }
        else {
            metà1 = stringa.Substring(0, stringa.Length / 2).ToCharArray(); //divido la stringa a metà, prendo la prima e la converto in array di char per riordinarne le lettere
            metà2 = stringa.Substring((stringa.Length / 2) + 1, stringa.Length / 2).ToCharArray(); //divido la stringa a metà, prendo la seconda e la converto in array di char per riordinarne le lettere
        }

        string metàOrdinata1 = string.Join("", InsertionSort(metà1));//ordino la prima metà della stringa e la riconverto da array di char in stringa
        string metàOrdinata2 = string.Join("", InsertionSort(metà2));//ordino la secondo metà della stringa e la riconverto da array di char in stringa
        //le due metà prima vengono convertite in array di char per riordinarle, poi vengono convertite in stringa dopo essere state ordinate per calcolarne l'hash con il metodo integrato

        if (metàOrdinata1.GetHashCode() == metàOrdinata2.GetHashCode()) {//se l'hash delle due metà ordinate coincide
            ritorno = true;
        }
        else {
            ritorno = false;
        }
        return ritorno;
    }

    static void ContaStringa() {
        string daEsserCercato, stringa;
        int occorrenze;
        Console.Write("Inserire il testo in cui cercare: ");
        daEsserCercato = Console.ReadLine();

        Console.Write("Inserire la frase da cercare: ");
        stringa = Console.ReadLine();

        //converto in caratteri minuscoli per semplificare la ricerca
        occorrenze = CercaStringa(daEsserCercato.ToLower(), stringa.ToLower());

        Console.WriteLine($"La stringa {daEsserCercato} contiene {stringa} {occorrenze} volte");
    }

    static int CercaStringa(string p_stringa1, string p_stringa2) {
        int i = 0, ritorno = 0;

        //creo un array per avere l'indice iniziale di ogni occorrenza del testo da trovare e lo riempio di -1 visto che sono indici non validi
        int[] indiciOccorrenze = new int[p_stringa1.Length];
        for (int j = 0; j < indiciOccorrenze.Length; j++) {
            indiciOccorrenze[j] = -1;
        }

        while (p_stringa1.Contains(p_stringa2)) {//finché c'è un'occorrenza
            ritorno++;//conta quante occorrenze ci sono state
            indiciOccorrenze[i] = p_stringa1.IndexOf(p_stringa2);//salva l'indice iniziale dell'occorrenza
            p_stringa1 = p_stringa1.Substring(indiciOccorrenze[i] + 1);//accorcia il testo per cercare oltre l'occorrenza appena trovata (1 serve per accorciare oltre la lettera)
            i++;
        }
        return ritorno;
    }
}