278 lines
10 KiB
C#
278 lines
10 KiB
C#
namespace ripasso4;
|
|
|
|
class Program {
|
|
const int dimensione = 5;
|
|
static void Main(string[] args) {
|
|
Console.Clear();
|
|
//dichiarazione e inizializzazione variabili
|
|
int scelta;
|
|
string[] arrayNomi = new string[dimensione], arrayCognomi = new string[dimensione], arrayNumeri;
|
|
|
|
//menu
|
|
do {
|
|
Console.WriteLine("Scegliere un'opzione:");
|
|
Console.WriteLine("1. Pari a sinistra, dispari a destra");
|
|
Console.WriteLine("2. Array paralleli");
|
|
Console.WriteLine("3. Inversione");
|
|
Console.WriteLine("0. Esci");
|
|
Console.Write("Scelta: ");
|
|
scelta = Convert.ToInt32(Console.ReadLine());
|
|
|
|
|
|
switch (scelta) {
|
|
case 0:
|
|
Console.Clear();
|
|
break;
|
|
case 1:
|
|
Console.Clear();
|
|
StampaArray(CreaVettoreOrdinato());
|
|
Pausa();
|
|
break;
|
|
case 2:
|
|
Console.Clear();
|
|
CreaVettoriParalleli(arrayCognomi, arrayNomi);
|
|
ControllaVettoriParalleli(arrayCognomi, arrayNomi);
|
|
CercaAlunni(arrayCognomi, arrayNomi);
|
|
Pausa();
|
|
break;
|
|
case 3:
|
|
Console.Clear();
|
|
arrayNumeri = CreaVettore();
|
|
Console.Clear();
|
|
Console.WriteLine("Array originale:");
|
|
StampaArray(arrayNumeri);
|
|
Console.WriteLine();
|
|
Console.WriteLine("Array invertito: ");
|
|
StampaArray(RibaltaVettore(arrayNumeri));
|
|
Pausa();
|
|
break;
|
|
default:
|
|
Console.WriteLine("Errore: scelta non valida");
|
|
Pausa();
|
|
break;
|
|
}
|
|
}
|
|
while (scelta != 0);
|
|
}
|
|
static void StampaArray(string[] p_insieme) {
|
|
for (int j = 0; j < p_insieme.Length; j++) {
|
|
Console.WriteLine("Elemento " + j + ": " + p_insieme[j]);
|
|
}
|
|
}
|
|
static string[] CreaVettoreOrdinato() {
|
|
int[] arrayCasuale = CreaArrayCasuale();
|
|
string[] ritorno = new string[dimensione];
|
|
int indiceDecrescenteArray = dimensione - 1, indiceCrescenteArray = 0;
|
|
for (int i = 0; i < dimensione; i++) {
|
|
if (arrayCasuale[i] % 2 != 0) {
|
|
ritorno[indiceDecrescenteArray] = Convert.ToString(arrayCasuale[i]);
|
|
indiceDecrescenteArray--;
|
|
}
|
|
else {
|
|
ritorno[indiceCrescenteArray] = Convert.ToString(arrayCasuale[i]);
|
|
indiceCrescenteArray++;
|
|
}
|
|
}
|
|
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(11);//per ogni posizione di ritorno assegno un valore a caso (metodo Random.Next)
|
|
}
|
|
return ritorno;
|
|
}
|
|
static void Pausa() {
|
|
Console.WriteLine("Premere un tasto per continuare. . .");
|
|
Console.ReadKey();
|
|
Console.Clear();
|
|
}
|
|
static void CreaVettoriParalleli(string[] p_arrayCognomi, string[] p_arrayNomi) {
|
|
|
|
for (int i = 0; i < dimensione; i++) { //Inserimento nomi e cognomi
|
|
Console.Clear();
|
|
|
|
//Inserimento cognomi
|
|
Console.Write("Inserire il cognome dell'alunno n." + (i + 1) + ": ");
|
|
p_arrayCognomi[i] = Console.ReadLine();
|
|
|
|
Console.Clear();
|
|
|
|
//Inserimento nomi
|
|
Console.Write("Inserire il nome dell'alunno n." + (i + 1) + ": ");
|
|
p_arrayNomi[i] = Console.ReadLine();
|
|
}
|
|
}
|
|
static void ControllaVettoriParalleli(string[] p_arrayCognomi, string[] p_arrayNomi) {
|
|
string correzione;
|
|
uint elemento;
|
|
char scelta;
|
|
|
|
do {
|
|
Console.Clear();
|
|
Console.WriteLine("Cognomi: ");
|
|
StampaArray(p_arrayCognomi);
|
|
Console.WriteLine();
|
|
Console.WriteLine("Nomi: ");
|
|
StampaArray(p_arrayNomi);
|
|
|
|
Console.Write("È corretto? [S/N] ");
|
|
scelta = Convert.ToChar(Console.ReadLine());
|
|
|
|
switch (scelta) {
|
|
case 'S':
|
|
break;
|
|
|
|
case 'N':
|
|
Console.Clear();
|
|
|
|
do {
|
|
Console.Write("Modificare la lista dei nomi o dei cognomi? ");
|
|
correzione = Console.ReadLine();
|
|
|
|
if (correzione != "nomi" && correzione != "cognomi") {
|
|
Console.WriteLine("Opzione non valida. Inserire [nomi] o [cognomi].");
|
|
Pausa();
|
|
}
|
|
}
|
|
while (correzione != "nomi" && correzione != "cognomi");
|
|
|
|
Console.Clear();
|
|
|
|
|
|
|
|
do {
|
|
switch (correzione) {
|
|
case "nomi":
|
|
StampaArray(p_arrayNomi);
|
|
break;
|
|
case "cognomi":
|
|
StampaArray(p_arrayCognomi);
|
|
break;
|
|
}
|
|
Console.WriteLine();
|
|
|
|
Console.Write("Digitare il numero dell'elemento sbagliato: ");
|
|
elemento = Convert.ToUInt32(Console.ReadLine());
|
|
|
|
if (elemento < 0 || elemento > dimensione - 1) {
|
|
Console.WriteLine("Numero di elemento non valido, inserire un numero compreso tra 0 e " + (dimensione - 1));
|
|
Pausa();
|
|
}
|
|
}
|
|
while (elemento < 0 || elemento > dimensione - 1);
|
|
|
|
Console.Clear();
|
|
|
|
switch (correzione) {
|
|
case "nomi":
|
|
Console.WriteLine("Elemento precedente: " + p_arrayNomi[elemento]);
|
|
break;
|
|
case "cognomi":
|
|
Console.WriteLine("Elemento precedente: " + p_arrayCognomi[elemento]);
|
|
break;
|
|
}
|
|
Console.WriteLine();
|
|
|
|
Console.Write("Inserire il nuovo elemento: ");
|
|
switch (correzione) {
|
|
case "nomi":
|
|
p_arrayNomi[elemento] = Console.ReadLine();
|
|
break;
|
|
case "cognomi":
|
|
p_arrayCognomi[elemento] = Console.ReadLine();
|
|
break;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
Console.WriteLine("Opzione non valida, inserire [S] o [N]");
|
|
Pausa();
|
|
break;
|
|
}
|
|
}
|
|
while (scelta != 'S');
|
|
}
|
|
static void CercaAlunni(string[] p_arrayCognomi, string[] p_arrayNomi) {
|
|
Console.Clear();
|
|
|
|
//dichiarazione e inizializzazione variabili
|
|
string daCercare;
|
|
int i = 0, indiceOccorrenze = 0;
|
|
bool daCercareEsiste = false;
|
|
|
|
const int valoreNonValido = -1;
|
|
int[] luogoOccorrenze = new int[dimensione + 1];
|
|
for (int j = 0; j < dimensione + 1; j++) {
|
|
luogoOccorrenze[j] = valoreNonValido;
|
|
}
|
|
|
|
|
|
do {
|
|
Console.Write("Per quale nome cercare? ");
|
|
daCercare = Console.ReadLine();
|
|
i = 0;
|
|
for (; i < dimensione; i++) {
|
|
if (p_arrayNomi[i] == daCercare) { //se daCercare è un nome che esiste
|
|
daCercareEsiste = true;
|
|
luogoOccorrenze[indiceOccorrenze] = i;
|
|
indiceOccorrenze++;
|
|
}
|
|
Console.WriteLine("Debug i: " + i);
|
|
}
|
|
|
|
if (!daCercareEsiste) {
|
|
Console.WriteLine("Il nome inserito non è stato trovato nella lista dei nomi, inserire un nome valido e riprovare");
|
|
Pausa();
|
|
}
|
|
}
|
|
while (!daCercareEsiste);
|
|
|
|
Console.Clear();
|
|
|
|
Console.WriteLine("I cognomi che corrispondono al nome " + daCercare + " sono:");
|
|
for (int j = 0; luogoOccorrenze[j] != valoreNonValido; j++) {
|
|
Console.WriteLine(p_arrayCognomi[luogoOccorrenze[j]]);
|
|
}
|
|
}
|
|
static string[] CreaVettore() {
|
|
string[] ritorno = new string[dimensione];
|
|
int i = 0, inputNumero;
|
|
string input;
|
|
const int minValue = 10, maxValue = 100;
|
|
|
|
do {
|
|
Console.Clear();
|
|
Console.WriteLine("Hai ancora " + (dimensione - i) + " numeri da poter inserire");
|
|
Console.Write("Inserire un numero ([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") {
|
|
inputNumero = Convert.ToInt32(input);
|
|
if (inputNumero < minValue || inputNumero > maxValue) {
|
|
Console.WriteLine("Il numero deve essere compreso tra " + minValue + " e " + maxValue);
|
|
Pausa();
|
|
}
|
|
else {
|
|
ritorno[i] = Convert.ToString(inputNumero);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
while (input != "q" && i < dimensione);
|
|
return ritorno;
|
|
}
|
|
static string[] RibaltaVettore(string[] p_array) {
|
|
string[] ritorno = new string[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;
|
|
}
|
|
} |