Domanda Alcuni esercizi in C e C++

[JunkCoder]

Ne ho fatti un paio a saltare, ero partito col volerli fare tutti ma non ho proprio tempo, ho implementato 1, 2, 3, 19 e 21.

Spoiler

#include <iostream>
#include <vector>
#include <string>

int ask_num(const char* prompt = nullptr)
{
    if (prompt == nullptr)
        prompt = "Inserisci un numero: ";

    int n;
    std::cout << prompt;
    std::cin >> n;
    std::cin.ignore();
    return n;
}

std::vector<int> ask_numbers(int count)
{
    std::vector<int> nums;
    for (int i = 0; i < count; i++)
        nums.push_back(ask_num());

    return nums;
}

void print_vector(const char* label, const std::vector<int> &nums)
{
    std::cout << label << std::endl;
    for (const auto& n : nums)
        std::cout << n << std::endl;
}


void esercizio1()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    double media = 0;
    int n_min = numbers.at(0);
    int n_max = n_min;
    for (const auto& x : numbers)
    {
        media += x;
        if (x < n_min)
            n_min = x;
        if (x > n_max)
            n_max = x;
    }
    media /= n;
    std::cout << "Media: " << media << std::endl 
        << "Min: " << n_min << std::endl << "Max: " << n_max << std::endl;
}

void esercizio2()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    std::vector<int> even_nums, odd_nums;
    for (const auto& n : numbers)
    {
        if ((n & 1) == 0)
            even_nums.push_back(n);
        else
            odd_nums.push_back(n);
    }
    print_vector("Even numbers:", even_nums);
    print_vector("Odd numbers:", odd_nums);
}

void esercizio3()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    for (int i = 0; i < numbers.size(); i++)
        if (numbers.at(i) == i)
            std::cout << "Value at index " << i << " has same value as its index" << std::endl;
}

void esercizio19()
{
    typedef struct
    {
        std::string Name;
        std::string PhoneNumber;
    } PhonebookEntry;

    std::string a, b;
    PhonebookEntry entry;
    std::vector<PhonebookEntry> phonebook;
    int c, i;
    do
    {
        std::cout << "Scegli un'operazione:" << std::endl
            << "[0] Esci dal programma" << std::endl
            << "[1] Inserisci contatto" << std::endl
            << "[2] Modifica contatto" << std::endl
            << "[3] Elimina contatto" << std::endl
            << "[4] Lista rubrica" << std::endl;

        std::cout << "Sono presenti " << phonebook.size() << " contatti in rubrica" << std::endl;
        c = ask_num("# ");
        switch (c)
        {
        case 1:
            // Inserimento
            std::cout << "Nome contatto: ";
            std::getline(std::cin, entry.Name);
            std::cout << "Numero di telefono: ";
            std::getline(std::cin, entry.PhoneNumber);
            phonebook.push_back(entry);
            std::cout << "Contatto inserito" << std::endl;
            break;
        case 2:
            // Modifica
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (auto& e : phonebook)
            {
                if (e.Name != a)
                    continue;

                std::cout << "Il contatto ha numero: " << e.PhoneNumber << std::endl
                    << "Inserisci nuovo numero: ";
                std::getline(std::cin, e.PhoneNumber);
            }
            break;
        case 3:
            // Eliminazione
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (i = 0; i < phonebook.size(); i++)
            {
                const auto e = phonebook.at(i);
                if (e.Name == a)
                {
                    phonebook.erase(phonebook.begin() + i);
                    std::cout << "Il contatto e' stato rimosso" << std::endl;
                    break;
                }
            }
            break;
        case 4:
            for (const auto& e : phonebook)
                std::cout << "Nome: " << e.Name << " - Numero: " << e.PhoneNumber << std::endl;
            break;
        }
    } while (c != 0);
}

void esercizio21()
{
    int n;
    do
    {
        n = ask_num("Inserisci la chiave tra 0 e 26: ");
    } while (n < 0 || n > 26);
  
    std::string plainText, cipherText;
    std::cout << "Inserisci il messaggio da cifrare: ";
    std::getline(std::cin, plainText);
    int len = plainText.size();
    for (int i = 0; i < len; i++)
    {
        char c = toupper(plainText[i]);
        if ('A' <= c && c <= 'Z')
            cipherText += (char)('A' + ((c - 'A' + n) % 26));
        else
            cipherText += c;
    }
    std::cout << "Messaggio cifrato: " << cipherText << std::endl;
}

int main()
{
    esercizio1();
    esercizio2();
    esercizio3();
    esercizio19();
    esercizio21();
    return 0;
}

 

[nfvblog]

Sto pubblicando alcuni esercizi in C per chi vuole iniziare e non solo, ovviamente sono in ordine di difficoltà, non richiedono grandi competenze in C ovviamente gli ultimi sfrutteranno anche la logica del puntatori, Liste concatenate, gestione delle stringe, ecc. Ovviamente vorrei vedere delle soluzioni differenti per gli stessi esercizi e vi auguro buon lavoro. ovviamente se volete potete caricare la soluzione qui sotto. Chiedo gentilmente di tenere toni pacati e di non insultare chi non riesce a svolgere un esercizio. Alcuni esercizi sono un po' cattivi, vi ho avvisati. Ovviamente questi esercizi vanno bene anche per il C++

 

[--- Ra ---]

Posto la mia soluzione del primo esercizio in C++, spero di vedere anche altre soluzioni.

Spoiler

#include <iostream>

using namespace std;

const int N = 10;

float calcolaMedia(int array[N]);
int trovaMinimo(int array[N]);
int trovaMassimo(int array[N]);

int main()
{
    int array[N] = {67, 44, 30, 20, 99, 68, 52, 102, 3, 73};
    cout << "Calcolo media in corso...\n";
    cout << "La media dell'array è pari a " << calcolaMedia(array) << endl;
    cout << "Il minimo dell'array è " << trovaMinimo(array) << endl;
    cout << "Il massimo dell'array è " << trovaMassimo(array) << endl;
    
    return 0;
}

float calcolaMedia(int array[N]){
    float somma = 0;
    for (int i = 0; i < N; i++){
        somma += array[i];
    }
    return somma / N;
}

int trovaMinimo(int array[N]){
    int pos = 0;
    for (int i = 1; i < N; i++){
        if (array[i] < array[pos]){
            pos = i;
        }
    }
    return array[pos];
}

int trovaMassimo(int array[N]){
    int pos = 0;
    for (int i = 1; i < N; i++){
        if (array[i] > array[pos]){
            pos = i;
        }
    }
    return array[pos];
}
[/SPOILER]

 

[--- Ra ---]

pubblico il Settimo Esercizio

Spoiler: Settimo Esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

void print_primi(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        if(arr[i]%arr[i] == 0 && arr[i]%1 == 0 && (arr[i]%2 != 0 && arr[i]%3 != 0 && arr[i]%4 != 0 && arr[i]%5 != 0 && arr[i]%6 != 0 && arr[i]%7 != 0 && arr[i]%8 != 0 && arr[i]%9 != 0)){
            cout << " " << arr[i] << " ";
        }
    }
    cout << endl;
}

void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}



int main(){

    const int DIM = 200;
    int*arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%200;
    }

    print(arr, DIM);
    cout << endl;
    print_primi(arr, DIM);

}

Credo che ci sia un errore che hai compiuto nella risoluzione del 7 esercizio. Il compito richiede di stampare tutti i numeri primi dell'array, quindi bisogna verificare se l'elemento i-esimo dell'array sia primo o meno. La tecnica del modulo è corretta, ma l'hai applicata in modo erroneo: se un numero non è divisibile per 2, non è divisibile nemmeno per i suoi multipli, quindi è inutile verificare, come hai fatto tu, se sia divisibile anche per 4, 6 o per 8 (sono operazioni in più che rallentano il programma). Discorso omologo per il 3. In secondo luogo hai omesso il controllo della divisibilità per 11.

 

[JunkCoder]

@JunkCoder , ho notato tra le righe di codice l'espressione "prompt = nullptr", di cosa si tratta? Non la conosco.

nullptr in C++ è il null pointer, ovvero NULL o 0. Quella funzione si aspetta un puntatore a stringa opzionale, se viene passata allora la mostrerà come prompt prima di leggere il numero, se non lo è allora è nullptr, se è nullptr viene usato un prompt di default (Inserisci un numero).

 

[--- Ra ---]

Credo di non aver capito come funzionano le funzioni Minimo/Massimo che hai implementato: Dichiari una variabile int pos = 0, scorri l'array e fai il controllo con l'if. Nell'if vedi se array < array[pos] ma questo controllo non è sempre vero? nel senso: se il tuo array in questo caso è: int array[N] = {67, 44, 30, 20, 99, 68, 52, 102, 3, 73}, il minimo quindi è 3. Quel controllo non restituisce sempre 0? perchè 0 è sempre < di tutti gli altri interi presenti nella struttura. Stesso principio con la funzione di Massimo. Chiedo scusa in anticipo, sono abbastanza arrugginito con il C.

È una strategia che serve per abbreviare il codice. Ipotizzo che il mio minimo si trova nella posizione 0 (anche se non ho alcun dato reale per dimostrarlo) e successivamente confronto tutti gli elementi dell'array con il mio minimo (in posizione 0) partendo dal secondo (posizione i) fino all'ultimo. Ogni volta che trovo un valore minore di quello che avevo ipotizzato in partenza, aggiorno la posizione. Alla fine del ciclo restituisco la posizione. Il controllo non restituisce assolutamente sempre zero perché io accedo all'elemento in posizione 0, non al valore 0.

 

[Shigekuni]

pubblico il Settimo Esercizio

Spoiler: Settimo Esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

void print_primi(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        if(arr[i]%arr[i] == 0 && arr[i]%1 == 0 && (arr[i]%2 != 0 && arr[i]%3 != 0 && arr[i]%5 != 0 && arr[i]%7 != 0 &&  arr[i]%11 != 0)){
            cout << " " << arr[i] << " ";
        }
    }
    cout << endl;
}

void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}



int main(){

    const int DIM = 200;
    int*arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%200;
    }

    print(arr, DIM);
    cout << endl;
    print_primi(arr, DIM);

}

Edit:
applicato il suggerimento di @CrazyMonk

 

[Shigekuni]

@CrazyMonk ho editato la risposta, per i multipli ti giuro che la mia testa mi ha detto "vedi che se è divisibile per il numero base, lo è pure per i multipli" ed io "cervello zitto, lo scrivo in caso poi lo levo" xD mentre la divisibilità per 11 l'avevo proprio dimenticata >.> così va bene? o potrei scrivere ancora meglio?

Messaggio unito automaticamente: 20 Luglio 2022

pubblico l'Ottavo Esercizio

Spoiler: Ottavo Esercizio

#include <iostream>
#include <cmath>

using namespace std;

void primi(int *primes, int &count, int n) {
    count = 0;
    
    for(int i=2; i <= n; i++) {
        bool primo = true;
    
        for(int j=2; j <= sqrt(i); j++) {
            if(i % j == 0) {
                primo = false;
                break;
            }
        }
        
        if(primo)  {
            
            primes[count++] = i;
            cout << " " << i << " ";
        }
    }
    cout << endl;
}


int main(){
    const int DIM = 50;
    int* arr = new int[DIM];
    int count;
    primi(arr, count, DIM);
}

Messaggio unito automaticamente: 20 Luglio 2022

pubblico il Nono Esercizio

Spoiler: Nono Esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

bool ripetuti(int* arr, const int DIM){
    bool esiste = false;
    for(int i=0; i<DIM; i++){
        for(int j=i+1; j<DIM; j++){
            if(arr[i] == arr[j]){
                esiste = true;
                break;
            }
        }
    }
    return esiste;
}

void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}


int main(){
    const int DIM = 25;
    int* arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()% 50;
    }

    print(arr, DIM);
    cout << endl;
    cout << ripetuti(arr, DIM) << endl;
}

Messaggio unito automaticamente: 20 Luglio 2022

pubblico il Decimo Esercizio

Spoiler: Decimo Esercizio

#include <iostream>
#include <cmath>
#include <cstdlib>

using namespace std;

template <typename T>
void Scelta(T &x, T &b){
    cout << "scegli il primo numero" << endl;
    cin >> x;
    cout << "scegli il secondo numero" << endl;
    cin >> b;
}


int somma(int a, int b){
    return a+b;
}

int sottrazione(int a, int b){
    return a-b;
}

int moltiplicazione(int a, int b){
    return a*b;
}

double divisione(int a, int b){
    double divisione;
    if(b == 0){
        cout << "errore, il denominatore non può essere 0" << endl;
        return -1.0;
    }
    divisione = double(a)/ double(b);
    return divisione;
}
template <typename T>
void SQuadrata(T& a){
    cout << "scegli di quale numero fare la radice quadrata " << endl;
    cin >> a;
}

double quadrata(int a){
    double f = double(a);
    return sqrt(f);
}


int main(){
    int a, b;
    int scelta;
    bool cal = true;
    do{
    cout << "benvenuto nella calcolatrice, digita un numero da 1 - 5 per la scelta, 0 per uscire" << endl;
    cout << "*********************************\n";
            cout << "\n";
            cout << "1) Esegui somma\n";
            cout << "2) Esegui differenza\n";
            cout << "3) Esegui prodotto\n";
            cout << "4) Esegui divisione\n";
            cout << "5) Esegui radice quadrata\n";
            cout << "\n";
            cout << "0) Esci dall'applicazione\n";
            cout << "*********************************\n";
            cin >> scelta;
            system("clear");
    }while(scelta > 6 && scelta <0);
    switch(scelta){
        case 1:
            Scelta(a, b);
            cout << somma(a, b) << endl;
            break;
        case 2:
            Scelta(a, b);
            cout << sottrazione(a,b) << endl;
            break;
        case 3:
            Scelta(a, b);
            cout << moltiplicazione(a,b) << endl;
            break;
        case 4:
            Scelta(a, b);
            cout << divisione(a,b) << endl;
            break;
        case 5:
            SQuadrata(a);
            cout << quadrata(a) << endl;
            break;
        case 0:
            exit(EXIT_SUCCESS);
    }
}

 

[Shigekuni]

pubblico l'Undicesimo Esercizio

Spoiler: Undicesimo Esercizio

#include <iostream>
#include <cstdlib>
using namespace std;
template<typename T>
class Node{
    private:
        T val;
        Node<T>* next;
        template<typename U>
        friend class List;       //friendship fra classi in modo da poter accedere per intero a variabile private e protected della classe List
    public:
        Node(T val){
            this->val = val;
            this->next = nullptr;
        }
        friend ostream& operator <<(ostream& os, Node<T> obj){
            os << "Node_val = " << obj.val << ", Node_Next = " << obj.getNext();
            return os;
        }

        Node<T>* getNext() const{
            return this->next;
        }
};
template<typename T>
class List{
    private:
        Node<T>* Head;
        int Size;
    public:
        List() {
            this->Head = nullptr;
            this->Size = 0;
        }
        int getSize(){
            return Size;
        }
        bool isEmpty(){
            return Head==nullptr;   //controllo se la lista è vuota
        }
        friend ostream& operator<<(ostream& os, const List<T>& obj) { //stampa lista
            os << "List head=" << *obj.Head << endl;
            Node<T> *ptr = obj.Head; //se uso ptr->next non stamperò un elemento
            while(ptr != nullptr) {
                os << "\t" << *ptr << endl;
                ptr = ptr->getNext(); //quì è meglio usare un metodo get che rendere l'ostream class friend in Node(nessuno può accedere ai campi di Node)
            }
            return os;
        }
        void insertHead(T val){
            if(isEmpty()){
                this->Head = new Node<T>(val);
                Size++;
                return;
            }
        }
        void insert(T val){
            if(isEmpty()){
                insertHead(val);
                return;
            }
            Node<T>* tmp = new Node<T>(val);
            tmp->next = Head;
            this->Head = tmp;
            Size++;
            return;
        }
};
void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}
int main(){
    const int DIM = 10;
    int* arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%10;
    }
    print(arr, DIM);
    List<int> Lista1;

    cout << "grandezza iniziale " << Lista1.getSize() << endl;
    for(int i=0; i<DIM; i++){
        Lista1.insert(arr[i]);
    }  
    cout << Lista1 << endl;
    cout << "grandezza finale " << Lista1.getSize() << endl;
}

 

[Shigekuni]

Pubblico il Dodicesimo Esercizio

Spoiler: Dodicesimo Esercizio

#include <iostream>
#include <climits>
#include <cstdlib>

using namespace std;

template <typename T>
class Node{
    private:
        T val;
        Node<T>* Next;

        template <typename U>
        friend class List;
  
    public:
        Node(T val){
            this->val = val;
            this->Next = nullptr;
        }

        friend ostream& operator <<(ostream& os, Node<T> obj){
            os << "Node_val = " << obj.val << ", Node_Next = " << obj.getNext();
            return os;
        }

        Node<T>* getNext() const{
            return this->Next;
        }
};

template <typename T>
class List{
    private:
        Node<T>* head;
        int Size;
  
    public:
        List(){
            this->head = nullptr;
            this->Size = 0;
        }

        bool isEmpty(){
            return head==nullptr;
        }

        Node<T>* getHead(){
            return this->head;
        }

        void insertHead(T val){
            if(isEmpty()){
                this->head = new Node<T>(val);
                this->Size++;
                return;
            }
        }

        friend ostream& operator<<(ostream& os, const List<T>& obj) { //stampa lista
            os << "List head=" << obj.head << endl;
            Node<T> *ptr = obj.head; //se uso ptr->next non stamperò un elemento
            while(ptr != nullptr) {
                os << "\t" << *ptr << endl;
                ptr = ptr->getNext(); //quì è meglio usare un metodo get che rendere l'ostream class friend in Node(nessuno può accedere ai campi di Node)
            }

            return os;
        }

        
void insert(T val){
            if(isEmpty()){
                insertHead(val);
                return;
            }
            Node<T>* tmp = new Node<T>(val);
            tmp->Next = head;
            this->head = tmp;
            this->Size++;
            return;
        }
};

void riempi_arr(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%15;
    }
}

void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}

int* ridotto(int* arr, const int DIM){
    int* arr1 = new int[DIM];
    int tmp = 0;
    for(int i=0; i<DIM; i++){
        for(int j=i+1; j<DIM; j++){
            if(arr[i] == arr[j]){
                arr1[i] = 0;
                break;
            }
            if(arr[i] != arr[j]){
                arr1[i] = arr[i];
            }
        }
        arr1[DIM-1] = arr[DIM-1];
    }
    return arr1;
}

int main(){
    List<int> List1;
    const int DIM = 10;
    int* arr = new int[DIM];
    riempi_arr(arr, DIM);
    print(arr, DIM);
    int* arr2 = ridotto(arr, DIM);
    print(arr2, DIM);

    for(int i=0; i<DIM; i++){
        if(arr2[i] == 0){
            continue;
        } else {
            List1.insert(arr2[i]);
        }
    }

    cout << List1 << endl;
}

Messaggio unito automaticamente: 27 Luglio 2022

pubblico il Tredicesimo Esercizio

Spoiler: Tredicesimo Esercizio

#include <iostream>

using namespace std;

template <typename T>
class Node{
    private:
        T val;
        Node<T>* Next;

        template <typename U>
        friend class List;

    public:
        Node(T val){
            this->val = val;
            this->Next = nullptr;
        }

        friend ostream& operator <<(ostream& os, Node<T> obj){
            os << "Node_val = " << obj.val << ", Node_Next = " << obj.getNext();
            return os;
        }

        Node<T>* getNext(){
            return this->Next;
        }
};

template <typename T>
class List{
    private:
        Node<T>* Head;
        int Size;
   
    public:
        List(){
            this->Head = nullptr;
            this->Size = 0;
        }

        bool isEmpty(){
            return this->Head==nullptr;
        }

        void insertHead(T val){
            if(isEmpty()){
                this->Head = new Node<T>(val);
                return;
            }
        }

        friend ostream& operator<<(ostream& os, const List<T>& obj) { //stampa lista
            os << "List head=" << *obj.Head << endl;
            Node<T> *ptr = obj.Head; //se uso ptr->next non stamperò un elemento
            while(ptr != nullptr) {
                os << "\t" << *ptr << endl;
                ptr = ptr->getNext(); //quì è meglio usare un metodo get che rendere l'ostream class friend in Node(nessuno può accedere ai campi di Node)
            }
            return os;
        }

        void insert(T val){
            if(isEmpty()){
                insertHead(val);
            }
            Node<T>* tmp = new Node<T>(val);
            tmp->Next = Head;
            this->Head = tmp;
            this->Size++;
            return;
        }
};

void riempi_arr(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%15;
    }
}

void print(int* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << " " << arr[i] << " ";
    }
    cout << endl;
}

int main(){

    const int DIM = 10;
    int* W = new int[DIM];
    int* V = new int[DIM];
    List<int> List1;

    riempi_arr(W, DIM);
    riempi_arr(V, DIM);
    print(W, DIM);
    cout << endl;
    print(V, DIM);
    cout << endl;
    for(int i=0; i<DIM; i++){
        List1.insert(W[i]);
        List1.insert(V[i]);
    }

    cout << List1 << endl;
}

Messaggio unito automaticamente: 27 Luglio 2022

pubblico il Quattordicesimo Esercizio

Spoiler: Quattordicesimo Esercizio

#include <iostream>
#include <string>

using namespace std;

bool palindroma(string s){
    int cont = 0;
    for(int i=0; i<s.length()/2; i++){
        if(s[i] == s[s.length()-i-1]){
            cont++;
        }
    }
    if(cont == (s.length()/2)){
        return true;
    }
    return false;
}

int main(){
    string s = "morta";
    string ss = "anna";
    string sss = "palindroma";
    string ssss = "aboba";
    cout << "la stringa = " << s << " ha un valore di " << palindroma(s) << endl;
    cout << "la stringa = " << ss << " ha un valore di " << palindroma(ss) << endl;
    cout << "la stringa = " << sss << " ha un valore di " << palindroma(sss) << endl;
    cout << "la stringa = " << ssss << " ha un valore di " << palindroma(ssss) << endl;

}

 

[nfvblog]

Ne ho fatti un paio a saltare, ero partito col volerli fare tutti ma non ho proprio tempo, ho implementato 1, 2, 3, 19 e 21.

Spoiler

#include <iostream>
#include <vector>
#include <string>

int ask_num(const char* prompt = nullptr)
{
    if (prompt == nullptr)
        prompt = "Inserisci un numero: ";

    int n;
    std::cout << prompt;
    std::cin >> n;
    std::cin.ignore();
    return n;
}

std::vector<int> ask_numbers(int count)
{
    std::vector<int> nums;
    for (int i = 0; i < count; i++)
        nums.push_back(ask_num());

    return nums;
}

void print_vector(const char* label, const std::vector<int> &nums)
{
    std::cout << label << std::endl;
    for (const auto& n : nums)
        std::cout << n << std::endl;
}


void esercizio1()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    double media = 0;
    int n_min = numbers.at(0);
    int n_max = n_min;
    for (const auto& x : numbers)
    {
        media += x;
        if (x < n_min)
            n_min = x;
        if (x > n_max)
            n_max = x;
    }
    media /= n;
    std::cout << "Media: " << media << std::endl
        << "Min: " << n_min << std::endl << "Max: " << n_max << std::endl;
}

void esercizio2()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    std::vector<int> even_nums, odd_nums;
    for (const auto& n : numbers)
    {
        if ((n & 1) == 0)
            even_nums.push_back(n);
        else
            odd_nums.push_back(n);
    }
    print_vector("Even numbers:", even_nums);
    print_vector("Odd numbers:", odd_nums);
}

void esercizio3()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    for (int i = 0; i < numbers.size(); i++)
        if (numbers.at(i) == i)
            std::cout << "Value at index " << i << " has same value as its index" << std::endl;
}

void esercizio19()
{
    typedef struct
    {
        std::string Name;
        std::string PhoneNumber;
    } PhonebookEntry;

    std::string a, b;
    PhonebookEntry entry;
    std::vector<PhonebookEntry> phonebook;
    int c, i;
    do
    {
        std::cout << "Scegli un'operazione:" << std::endl
            << "[0] Esci dal programma" << std::endl
            << "[1] Inserisci contatto" << std::endl
            << "[2] Modifica contatto" << std::endl
            << "[3] Elimina contatto" << std::endl
            << "[4] Lista rubrica" << std::endl;

        std::cout << "Sono presenti " << phonebook.size() << " contatti in rubrica" << std::endl;
        c = ask_num("# ");
        switch (c)
        {
        case 1:
            // Inserimento
            std::cout << "Nome contatto: ";
            std::getline(std::cin, entry.Name);
            std::cout << "Numero di telefono: ";
            std::getline(std::cin, entry.PhoneNumber);
            phonebook.push_back(entry);
            std::cout << "Contatto inserito" << std::endl;
            break;
        case 2:
            // Modifica
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (auto& e : phonebook)
            {
                if (e.Name != a)
                    continue;

                std::cout << "Il contatto ha numero: " << e.PhoneNumber << std::endl
                    << "Inserisci nuovo numero: ";
                std::getline(std::cin, e.PhoneNumber);
            }
            break;
        case 3:
            // Eliminazione
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (i = 0; i < phonebook.size(); i++)
            {
                const auto e = phonebook.at(i);
                if (e.Name == a)
                {
                    phonebook.erase(phonebook.begin() + i);
                    std::cout << "Il contatto e' stato rimosso" << std::endl;
                    break;
                }
            }
            break;
        case 4:
            for (const auto& e : phonebook)
                std::cout << "Nome: " << e.Name << " - Numero: " << e.PhoneNumber << std::endl;
            break;
        }
    } while (c != 0);
}

void esercizio21()
{
    int n;
    do
    {
        n = ask_num("Inserisci la chiave tra 0 e 26: ");
    } while (n < 0 || n > 26);
 
    std::string plainText, cipherText;
    std::cout << "Inserisci il messaggio da cifrare: ";
    std::getline(std::cin, plainText);
    int len = plainText.size();
    for (int i = 0; i < len; i++)
    {
        char c = toupper(plainText[i]);
        if ('A' <= c && c <= 'Z')
            cipherText += (char)('A' + ((c - 'A' + n) % 26));
        else
            cipherText += c;
    }
    std::cout << "Messaggio cifrato: " << cipherText << std::endl;
}

int main()
{
    esercizio1();
    esercizio2();
    esercizio3();
    esercizio19();
    esercizio21();
    return 0;
}

non fa nulla, era semplicemente un modo per confrontarsi e anche per creare uno schedario di esercizi da riprendere in seguito

 

[--- Ra ---]

Posto soluzione del 3 esercizio:

Spoiler

#include <iostream>
#include <random>
#include <ctime>

using namespace std;

const int N = 20;

int main()
{
    int array[N];
    //Inizializzo il seme per la generazione random
    int seme = time(NULL);
    srand(seme);
    //Assegno valori random tra 0 e 100 all'array
    for(int i = 0; i < N; i++){
       array[i] = rand() % 100 + 1;
    }
    //Stampo gli elementi che rispettano la condizione richiesta
    for(int i = 0; i < N; i++){
        if (array[i] == i){
            cout << array[i] << endl;
        }
    }
    
    return 0;
}

Messaggio unito automaticamente: 6 Giugno 2022

Ne ho fatti un paio a saltare, ero partito col volerli fare tutti ma non ho proprio tempo, ho implementato 1, 2, 3, 19 e 21.

Spoiler

#include <iostream>
#include <vector>
#include <string>

int ask_num(const char* prompt = nullptr)
{
    if (prompt == nullptr)
        prompt = "Inserisci un numero: ";

    int n;
    std::cout << prompt;
    std::cin >> n;
    std::cin.ignore();
    return n;
}

std::vector<int> ask_numbers(int count)
{
    std::vector<int> nums;
    for (int i = 0; i < count; i++)
        nums.push_back(ask_num());

    return nums;
}

void print_vector(const char* label, const std::vector<int> &nums)
{
    std::cout << label << std::endl;
    for (const auto& n : nums)
        std::cout << n << std::endl;
}


void esercizio1()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    double media = 0;
    int n_min = numbers.at(0);
    int n_max = n_min;
    for (const auto& x : numbers)
    {
        media += x;
        if (x < n_min)
            n_min = x;
        if (x > n_max)
            n_max = x;
    }
    media /= n;
    std::cout << "Media: " << media << std::endl
        << "Min: " << n_min << std::endl << "Max: " << n_max << std::endl;
}

void esercizio2()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    std::vector<int> even_nums, odd_nums;
    for (const auto& n : numbers)
    {
        if ((n & 1) == 0)
            even_nums.push_back(n);
        else
            odd_nums.push_back(n);
    }
    print_vector("Even numbers:", even_nums);
    print_vector("Odd numbers:", odd_nums);
}

void esercizio3()
{
    int n = ask_num("Quanti numeri vuoi inserire? ");
    auto numbers = ask_numbers(n);
    for (int i = 0; i < numbers.size(); i++)
        if (numbers.at(i) == i)
            std::cout << "Value at index " << i << " has same value as its index" << std::endl;
}

void esercizio19()
{
    typedef struct
    {
        std::string Name;
        std::string PhoneNumber;
    } PhonebookEntry;

    std::string a, b;
    PhonebookEntry entry;
    std::vector<PhonebookEntry> phonebook;
    int c, i;
    do
    {
        std::cout << "Scegli un'operazione:" << std::endl
            << "[0] Esci dal programma" << std::endl
            << "[1] Inserisci contatto" << std::endl
            << "[2] Modifica contatto" << std::endl
            << "[3] Elimina contatto" << std::endl
            << "[4] Lista rubrica" << std::endl;

        std::cout << "Sono presenti " << phonebook.size() << " contatti in rubrica" << std::endl;
        c = ask_num("# ");
        switch (c)
        {
        case 1:
            // Inserimento
            std::cout << "Nome contatto: ";
            std::getline(std::cin, entry.Name);
            std::cout << "Numero di telefono: ";
            std::getline(std::cin, entry.PhoneNumber);
            phonebook.push_back(entry);
            std::cout << "Contatto inserito" << std::endl;
            break;
        case 2:
            // Modifica
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (auto& e : phonebook)
            {
                if (e.Name != a)
                    continue;

                std::cout << "Il contatto ha numero: " << e.PhoneNumber << std::endl
                    << "Inserisci nuovo numero: ";
                std::getline(std::cin, e.PhoneNumber);
            }
            break;
        case 3:
            // Eliminazione
            std::cout << "Cerca per nome: ";
            std::getline(std::cin, a);
            for (i = 0; i < phonebook.size(); i++)
            {
                const auto e = phonebook.at(i);
                if (e.Name == a)
                {
                    phonebook.erase(phonebook.begin() + i);
                    std::cout << "Il contatto e' stato rimosso" << std::endl;
                    break;
                }
            }
            break;
        case 4:
            for (const auto& e : phonebook)
                std::cout << "Nome: " << e.Name << " - Numero: " << e.PhoneNumber << std::endl;
            break;
        }
    } while (c != 0);
}

void esercizio21()
{
    int n;
    do
    {
        n = ask_num("Inserisci la chiave tra 0 e 26: ");
    } while (n < 0 || n > 26);
 
    std::string plainText, cipherText;
    std::cout << "Inserisci il messaggio da cifrare: ";
    std::getline(std::cin, plainText);
    int len = plainText.size();
    for (int i = 0; i < len; i++)
    {
        char c = toupper(plainText[i]);
        if ('A' <= c && c <= 'Z')
            cipherText += (char)('A' + ((c - 'A' + n) % 26));
        else
            cipherText += c;
    }
    std::cout << "Messaggio cifrato: " << cipherText << std::endl;
}

int main()
{
    esercizio1();
    esercizio2();
    esercizio3();
    esercizio19();
    esercizio21();
    return 0;
}

@JunkCoder , ho notato tra le righe di codice l'espressione "prompt = nullptr", di cosa si tratta? Non la conosco.

 

[Fulvy]

int trovaMinimo(int array[N]){
int pos = 0;
for (int i = 1; i < N; i++){
if (array < array[pos]){
pos = i;
}
}
return array[pos];
}

Credo di non aver capito come funzionano le funzioni Minimo/Massimo che hai implementato: Dichiari una variabile int pos = 0, scorri l'array e fai il controllo con l'if. Nell'if vedi se array < array[pos] ma questo controllo non è sempre vero? nel senso: se il tuo array in questo caso è: int array[N] = {67, 44, 30, 20, 99, 68, 52, 102, 3, 73}, il minimo quindi è 3. Quel controllo non restituisce sempre 0? perchè 0 è sempre < di tutti gli altri interi presenti nella struttura. Stesso principio con la funzione di Massimo. Chiedo scusa in anticipo, sono abbastanza arrugginito con il C.

 

[Fulvy]

È una strategia che serve per abbreviare il codice. Ipotizzo che il mio minimo si trova nella posizione 0 (anche se non ho alcun dato reale per dimostrarlo) e successivamente confronto tutti gli elementi dell'array con il mio minimo (in posizione 0) partendo dal secondo (posizione i) fino all'ultimo. Ogni volta che trovo un valore minore di quello che avevo ipotizzato in partenza, aggiorno la posizione. Alla fine del ciclo restituisco la posizione. Il controllo non restituisce assolutamente sempre zero perché io accedo all'elemento in posizione 0, non al valore 0.

Ok chiaro, hai ragione: ho capito male il funzionamento di pos. Ti ringrazio

 

[--- Ra ---]

Esercizi 7 e 9:

Spoiler

#include <iostream>
#include <random>
#include <ctime>

using namespace std;

const int N = 20;

int main()
{
    int array[N];
    //Inizializzo il seme per la generazione random
    int seme = time(NULL);
    srand(seme);
    //Assegno valori random tra 0 e 100 all'array
    for(int i = 0; i < N; i++){
       array[i] = rand() % 100 + 1;
    }
    //Stampo gli elementi che sono numeri primi (metodo meno efficiente, ma alternativo a quello del conteggio dei divisori)
    for(int i = 0; i < N; i++){
        if ((array[i] % 2) != 0 && (array[i] % 3) != 0 && (array[i] % 5) != 0 && (array[i] % 7) != 0 && (array[i] % 11) != 0){
            cout << array[i] << endl;
        }
    }
    
    return 0;
}

#include <iostream>
#include <random>
#include <ctime>

using namespace std;

const int N = 20;

int contaNumero(int array[N], int numero);
bool numeriRipetuti(int array[N]);

int main()
{
    int array[N];
    //Inizializzo il seme per la generazione random
    int seme = time(NULL);
    srand(seme);
    //Assegno valori random tra 0 e 100 all'array
    for(int i = 0; i < N; i++){
       array[i] = rand() % 100 + 1;
    }
    
    for(int i = 0; i < N; i++){
       cout << array[i] << endl;
    }
    
    if (numeriRipetuti(array)){
        cout << "Sono presenti numeri che si ripetono\n"; 
    } else {
        cout << "Non sono presenti numeri che si ripetono\n";
    }
    
    return 0;
}

int contaNumero(int array[N], int numero){
    int conta = 0;
    for (int i = 0; i < N; i++){
        if (array[i] == numero){
            conta++ ;
        }
    }
    return conta;
}

bool numeriRipetuti(int array[N]){
    for (int i = 0; i < N; i++){
        if (contaNumero(array, array[i]) >= 2){
            return true;
        }
    }
    return false;
}

 

[--- Ra ---]

Pubblico esercizio numero 10 (Calcolatrice), dato che avevo un po' di tempo ho fatto una cosa sfiziosa anche con menu di comandi

Spoiler

#include <iostream>
#include <cmath>

using namespace std;

int schermoMenu();
void convalidaIntero(int min, int max, string messaggio, int &scelta);
int somma(int a, int b);
int differenza(int a, int b);
int prodotto(int a, int b);
float divisione(float a, float b);

int main(){
    int scelta;
    
    while (true){
        scelta = schermoMenu();
        if (scelta == 0){
            cout << "Chiusura applicazione...\n";
            break;
        }
        if (scelta == 1){
            int numero1;
            int numero2;
            cout << "Inserire primo numero:\n";
            cin >> numero1;
            cout << "Inserire secondo numero:\n";
            cin >> numero2;
            cout << "La somma dei due numeri è " << somma(numero1, numero2) << endl;
        }
        if (scelta == 2){
            int numero1;
            int numero2;
            cout << "Inserire primo numero:\n";
            cin >> numero1;
            cout << "Inserire secondo numero:\n";
            cin >> numero2;
            cout << "La differenza dei due numeri è " << differenza(numero1, numero2) << endl;
        }
        if (scelta == 3){
            int numero1;
            int numero2;
            cout << "Inserire primo numero:\n";
            cin >> numero1;
            cout << "Inserire secondo numero:\n";
            cin >> numero2;
            cout << "Il prodotto dei due numeri è " << prodotto(numero1, numero2) << endl;
        }
        if (scelta == 4){
            float numero1;
            float numero2;
            cout << "Inserire primo numero:\n";
            cin >> numero1;
            cout << "Inserire secondo numero:\n";
            cin >> numero2;
            while (numero2 == 0){
                cout << "Errore. Impossibile eseguire una divisione per zero. Inserire un altro divisore!\n";
                cin >> numero2;
            }
            cout << "La divisione dei due numeri è " << divisione(numero1, numero2) << endl;
        }
        if (scelta == 5){
            int numero;
            cout << "Inserire numero al quale si vuole applicare la funzione radice: \n";
            cin >> numero;
            while (numero < 0){
                cout << "Impossibile applicare la funzione radice a numeri negativi. Inserire un numero maggiore o uguale a 0: \n";
                cin >> numero;
            }
            cout << "La radice del numero inserito è " << sqrt(numero) << endl;
        }
    }
    return  0;
}

int schermoMenu(){
    int scelta;
    
    cout << "*********************************\n";
    cout << "---- MENU CALCOLATRICE ----\n";
    cout << "\n";
    cout << "1) Esegui somma\n";
    cout << "2) Esegui differenza\n";
    cout << "3) Esegui prodotto\n";
    cout << "4) Esegui divisione\n";
    cout << "5) Esegui radice quadrata\n";
    cout << "\n";
    cout << "0) Esci dall'applicazione\n";
    cout << "*********************************\n";
    
    convalidaIntero(0, 5, "Scelta---->", scelta);
    return scelta;
}

void convalidaIntero(int min, int max, string messaggio, int &scelta){
    cout << messaggio << endl;
    cin >> scelta;
    while (scelta < min || scelta > max){
        cout << "Errore. Inserire un numero compreso tra " << min << " e " << max << endl;
        cout << messaggio << endl;
        cin >> scelta;
    }
    return;
}

int somma(int a, int b){
    int somma;
    somma = a + b;
    return somma;
}

int differenza(int a, int b){
    int differenza;
    differenza = a - b;
    return differenza;
}

int prodotto(int a, int b){
    int prodotto;
    prodotto = a * b;
    return prodotto;
}

float divisione(float a, float b){
    float divisione;
    divisione =  a / b;
    return divisione;
}

 

[enk17]

esercizio 9.

Spoiler

#include <iostream>

using namespace std;

bool verifica(int n[],int size);


int main()
{
    int* array, totale,ris;
    cout << "quanti numeri vuoi inserire? ";
    cin >> totale;
    array = new int[totale];

    for (int j = 0; j < totale; j++)
    {
        cout << "inserisci il numero ";
        cin >> array[j];
    }
    ris = verifica(array, totale);

    if (ris == 0)
    {
        cout << "non ci sono numeri ripetuti ";
    }
    else if (ris == 1)
    {
        cout << "ci sono numeri ripetuti ";
    }
    return 0;
}

bool verifica(int n[],int size)
{
    bool check = false;

    for (int i = 1; i < size; i++)
    {
        for (int j = 0; j < i; j++)
        {
            if (n[i] == n[j])
            {
                check = true;
            }
        }

    }

    return check;
}

 

[Shigekuni]

Pubblico il primo esercizio

Spoiler: primo esercizio

#include <iostream>
#include <climits>
#include <cstdlib>

using namespace std;

template <typename T>
T minimo(T *arr, const int DIM){
    int min = INT_MAX;
    for(int i=0; i<DIM; i++){
        if(arr[i] < min){
            min = arr[i];
        }
    }
    return min;
}

template <typename T>
T massimo(T *arr, const int DIM){
    int max = INT_MIN;
    for(int i=0; i<DIM; i++){
        if(arr[i] > max){
            max = arr[i];
        }
    }
    return max;
}

template <typename T>
void print(T *arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

template <typename T>
double media(T *arr, const int DIM, int &N){
    double mean = 0.0;
    cout << "scegli di quanti numeri vuoi la media" << endl;
    do{
    cin >> N;
    }while(N >= DIM);
    int i = 0;
    while(i<N){
        int tmp;
        cout << "scegli la posizione dell'addendo numero " << i << " da sommare" << endl;
        mean+=arr[tmp%DIM];
        i++;
    }
    return mean/=N;
}

int main(){
    const int DIM = 10;
    int* arr = new int[DIM];
    int N;
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%16 - 1;
    }
    print(arr, DIM);
    cout << "Massimo = " << massimo(arr, DIM) << endl;
    cout << "Minimo = " << minimo(arr, DIM) << endl;
    cout <<  media(arr, DIM, N) << " è una media basata su " << N << " elementi a scelta dell'utente " << endl;

}

Messaggio unito automaticamente: 18 Luglio 2022

Pubblico il secondo esercizio

Spoiler: Secondo Esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

template <typename T>
void Pari(T* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        int tmp = rand()% 100 + 1;
        if((tmp%2) == 0){
            arr[i] = tmp;
        } else {
            arr[i] = -1;
            cout << "valore = " << tmp << " è un valore dispari " << endl;
        }
    }
}

template <typename T>
void riempi(T* arr, const int DIM){
    cout << "inserisci i valori nell'array" << endl;
    T tmp = 0;
    int i = 0;
    do{
        cout << "inserisci il valore in posizione " << i << endl;
        cin >> tmp;
        if(tmp%2 == 0){
            arr[i] = tmp;
        } else {
            cout << tmp << " non è un valore valido, inserire un valore Pari " << endl;
            while(tmp%2 != 0){
                cin >> tmp;
            }
        }
        i++;
    }while(i<DIM);
}

template <typename T>
void print(T *arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main(){
    const int DIM = 10;
    int* arr = new int[DIM];
    Pari(arr, DIM);         //qui i valore vengono scelti randomicamente tra 1 e 100
    //riempi(arr, DIM);     //qui i valori vengono scelti dall'utente
    print(arr, DIM);


}

Messaggio unito automaticamente: 18 Luglio 2022

Pubblico il terzo esercizio

Spoiler: terzo esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

template <typename T>
void print(T* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        if(arr[i] == i){
            cout << arr[i] << " " ;
        }
    }
    cout << endl;
}

int main(){
    const int DIM = 10;
    int* arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%10;
    }

    print(arr, DIM);
}

Messaggio unito automaticamente: 18 Luglio 2022

Pubblico il quarto esercizio

Spoiler: quarto esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

template <typename T>
T* terzo(T* arr1, T* arr2, const int DIM){
    int* arr3 = new int[DIM];
    int tmp = rand()%2;
    switch(tmp){
        case 0:
        for(int i=0; i<DIM; i++){
            arr3[i] = arr1[i];
        }
        break;
        case 1:
            for(int i=0; i<DIM; i++){
                arr3[i] = arr2[i];
            }
        break;
    }
    return arr3;
}

template <typename T>
void print(T* arr, const int DIM){
    for(int i=0; i<DIM; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main(){

    const int DIM = 10;
    int* arr1 = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr1[i] = rand()% 10;
    }

    int* arr2 = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr2[i] = rand()% 10;
    }
    int* arr3 = new int[DIM];
    arr3 = terzo(arr1, arr2, DIM);

    print(arr1, DIM);
    cout << endl;
    print(arr2, DIM);
    cout << endl;
    print(arr3, DIM);
    cout << endl;
}

Messaggio unito automaticamente: 19 Luglio 2022

Pubblico il quinto esercizio

Spoiler: quinto esercizio

#include <iostream>

using namespace std;

int FB(int n){
    if(n == 0 || n == 1){
        return 1;
    }
    int sum_1 = 1, sum_2 = 1, x;
    for(int i=2; i<=n; i++){
        x = sum_2;
        sum_2 = sum_1;
        sum_1 = x + sum_2;
        cout << sum_1 << endl;
    }
    return sum_1;
}


int main(){
    FB(10);
}

Messaggio unito automaticamente: 19 Luglio 2022

Pubblico il Sesto Esercizio

Spoiler: Sesto Esercizio

#include <iostream>
#include <cstdlib>

using namespace std;

void sort(int* arr, int len){
    int temp, j;
    for(int i=1; i<len; i++) {
        temp=arr[i];
            j=i-1;
        while((arr[j]>temp) && (j>=0)) {
                arr[j+1]=arr[j];
                j--;
            }
        arr[j+1]=temp;
        }
}

void print(int* arr, int len){
    for(int i=0; i<len; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main(){
    const int DIM = 10;
    int* arr = new int[DIM];
    for(int i=0; i<DIM; i++){
        arr[i] = rand()%15;
    }
    print(arr, DIM);
    sort(arr, DIM);
    print(arr, DIM);

}