array_funzioni_4/Program.cs

namespace array_funzioni_4;

class Program
{
    const int dimensione = 10;
    static void Main(string[] args)
    {
        Console.Clear();
        //dichiarazione e inizializzazione variabili
        int scelta;

        //menu
        do{
            Console.WriteLine("Scegliere un'opzione:");
            Console.WriteLine("1. Stampa zig zag");
            Console.WriteLine("2. Somma pari dispari");
            Console.WriteLine("3. Array invertito");
            Console.WriteLine("4. Tre consecutivi");
            Console.WriteLine("5. Uno doppio dell'altro");
            Console.WriteLine("0. Esci");
            Console.Write("Scelta: ");
            scelta=Convert.ToInt32(Console.ReadLine());

        
            switch(scelta){
                case 0:
                    Console.Clear();
                    break;
                case 1:
                    Console.Clear();
                    StampaArrayZigZag(CreaArrayCasuale());
                    Pausa();
                    break;
                case 2:
                    Console.Clear();
                    Console.WriteLine(StampaPariDispari(CreaArrayCasuale()));
                    Pausa();
                    break;
                case 3:
                    Console.Clear();
                    StampaArray(InvertiArray(CreaArrayCasuale()));
                    Pausa();
                    break;
                case 4:
                    Console.Clear();
                    if(TreConsecutivi(CreaArray()) == true){
                        Console.WriteLine("Tre valori consecutivi uguali");
                    }
                    else{
                        Console.WriteLine("NO");
                    }
                    Pausa();
                    break;
                case 5:
                    Console.Clear();
                    if(DoppioDellAltro(CreaArrayCasuale()) == true){
                        Console.WriteLine("Doppio uno dell'altro");
                    }
                    else{
                        Console.WriteLine("NO");
                    }
                    Pausa();
                    break;
                default:
                    Console.WriteLine("Errore: scelta non valida");
                    Pausa();
                    break;
            }
        }
        while(scelta!=0);
    }
    static void Pausa(){
        Console.WriteLine("Premere un tasto per continuare. . .");
        Console.ReadKey();
        Console.Clear();
    }

    static int[] CreaArray(){
        int[] ritorno = new int[dimensione];
        int i = 0;
        string input;

        do{
            Console.Write("Inserire un numero, massimo " +dimensione+ " numeri ([q] per uscire): ");
            input = Console.ReadLine(); //non posso ancora fare il catch dell'eccezione se viene inserito un qualcosa che non sia un numero o q
            if(input != "q"){
                ritorno[i] = Convert.ToInt32(input);
            }
            i++;
        }
        while(input!="q" && i<dimensione);
        return ritorno;
    }

    static int[] CreaArrayCasuale(){
        //dichiarazione e inizializzazione variabili
        Random caso = new Random();
        int[] ritorno = new int[dimensione];

        for(int i=0; i<dimensione; i++){
            ritorno[i]=caso.Next(Int32.MinValue, Int32.MaxValue);//per ogni posizione di ritorno assegno un valore a caso (metodo Random.Next)
        }
        return ritorno;
    }
    
    static void StampaArray(int [] p_array) {
        for (int j=0; j<p_array.Length; j++){
            Console.WriteLine("Elemento " +j+ ": " +p_array[j]);
        } 
    }

    static void StampaArrayZigZag(int[] p_array){
        int j = dimensione - 1, k = 0;
        for (int i=0; i<dimensione; i++){
            Console.Write("Elemento " + i + ": ");
            if(i%2 != 0){//se dispari. Con questa condizione posso stampare prima un elemento, poi l'ultimo, poi il secondo... incrementando di 1 i contatori invece che di 2
                Console.WriteLine(p_array[j]);//parto dall'ultimo elemento a scendere
                j--;
            }
            else{//se pari
                Console.WriteLine(p_array[k]);//parto dal primo elemento a salire
                k++;
            }
        }
    }

    static string StampaPariDispari(int[] p_array){
        int sommaPari = 0, sommaDispari = 0, i = 0;
        string ritorno;
        while(i<dimensione){//non è un ciclo for perché non posso aumentare il contatore di 2, ma solo di 1
            sommaPari = sommaPari + p_array[i];
            i = i + 2;
        }
        i = 1;
        while(i<dimensione){//non è un ciclo for perché non posso aumentare il contatore di 2, ma solo di 1
            sommaDispari = sommaDispari + p_array[i];
            i = i + 2;
        }
        if (sommaPari == sommaDispari){
            ritorno = "Pari e dispari uguali";
        }
        else{
            ritorno = "Pari e dispari diversi";
        }
        return ritorno;
    }

    static int[] InvertiArray(int[] p_array){
        int[] ritorno = new int[dimensione];
        int j = dimensione - 1;

        for(int i=0; i<dimensione; i++){
            ritorno[i] = p_array[j];//il primo elemento di ritorno è l'ultimo di p_array e così via, i e j variano in opposto
            j--;
        }
        return ritorno;
    }

    static bool TreConsecutivi(int[] p_array){
        bool ritorno = false;
        int i = 0;
        //copiato da Ottolini
        while(i<dimensione-2 && ritorno == false){//mi fermo a dimensione-2 perché con la condizione qua sotto in una volta controllo 3 elementi uno dietro l'altro, quindi alla terz'ultima pos. sto già il penultimo e l'ultimo, altrimenti al giro successivo l'indice è out of bound. Il while è per uscire non appena vengono trovati i tre numeri
            if(p_array[i] == p_array[i+1] && p_array[i] == p_array[i+2]){
                ritorno = true;
            }
            i++;
        }
        return ritorno;
    }

    static bool DoppioDellAltro(int[] p_array){
        bool ritorno = false;
        int i = 0, j = 0;

        while(ritorno==false && i<dimensione){
            while(ritorno==false && j<dimensione){//la prima condizione è ripetuta in modo da uscire subito dal ciclo per il primo consecutivo non appena viene trovato
                if (p_array[j] == p_array[i]*2){
                    ritorno = true;
                }
                j++;
            }
            j = 0;
            i++;
        }
        return ritorno;
    }
}