Track
/
C++
C++
/
Esercizi
/
Lasagna
Lasagna

Lasagna

Esercizio di apprendimento

Introduzione

Le basi

Per dare inizio al viaggio con C++, partiamo da variabili, chiamate di funzioni e commenti.

I commenti

I commenti sono di due tipi: su una sola riga o su più righe. Tutto ciò che segue // sulla stessa riga viene ignorato dal compilatore. I commenti su più righe sono anche noti come commenti in stile C. Sono delimitati da /* e */. Anche tutto ciò che si trova tra questi due viene ignorato.

Le variabili

C++ è un linguaggio tipizzato. Tutti i tipi devono essere noti al momento della compilazione e in genere devi dichiararli esplicitamente. Il tipo di una variabile non può cambiare. Una variabile intera con il nome years si può dichiarare così:

int years;

È buona norma inizializzare le variabili al momento della dichiarazione. C++ offre diversi meccanismi per farlo. La versione con le parentesi graffe è più in linea con il C++ moderno, ma anche la versione con il segno di uguale è molto comune.

int tomatoes{80};
int potatoes = 40;
Caution

C++ consente effettivamente di usare variabili non inizializzate. Finché la variabile non viene impostata deliberatamente, è indefinita e potrebbe contenere qualsiasi cosa. Per evitare errori di uso prima dell'impostazione e comportamenti indefiniti, è consigliabile inizializzare sempre. Un comportamento indefinito può far crashare il programma nel momento peggiore, proprio mentre fino a poco prima funzionava bene. Non lo si ripeterà mai abbastanza: evita i comportamenti indefiniti a ogni costo.

Le operazioni aritmetiche

Gli operatori aritmetici come *, + o - possono far parte di un'espressione come 3 * 2 o tomatoes + potatoes.

Aggiornare le variabili

Puoi riassegnare le variabili, purché mantengano il loro tipo:

tomatoes = tomatoes - 5; // tomatoes is now 75
potatoes = (32 * 2) + 11; // potatoes is now 75 as well

Le funzioni

Le funzioni hanno un nome, un tipo restituito e un elenco di parametri (possibilmente vuoto). Un esempio di funzione chiamata always_fortyseven che restituirebbe sempre 47 è questo:

int always_fortyseven() {
    return 47;
}

Ecco vip_fee, che ha un parametro:

int vip_fee(int standard_fee) {
    /*
    vip_fee calculates the vip fee based on the standard_fee.
    */
    int vip_multi{3};
    return standard_fee * vip_multi;
}

O total_fee, una funzione con tre parametri e una chiamata a un'altra funzione.

int total_fee(int vips, int adults, int kids) {
    /*
    total_fee calculates the total price for a group of VIP and adult guests with kids.
    Kids get a flat discount on the standard fee.
    VIP guest fees are calculated by calling vip_fee.
    */
    int standard_fee{30};
    int kids_discount{15};

    int kids_total_fee = kids * (standard_fee - kids_discount);
    int vips_total_fee = vips * vip_fee(standard_fee);
    int adult_total_fee = adults * standard_fee;

    return vips_total_fee + adult_total_fee + kids_total_fee;
}

In C++ le funzioni non restituiscono il valore dell'ultima istruzione come in altri linguaggi. La parola chiave return è necessaria perché il codice venga compilato.

Gli spazi bianchi

Gli spazi bianchi servono a formattare il codice sorgente e includono spazi, tabulazioni e ritorni a capo. Dato che il compilatore ignora gli spazi bianchi superflui, puoi usarli per strutturare il codice. Un uso intelligente degli spazi bianchi può migliorare la leggibilità del codice. Esistono diversi standard di formattazione, ma sono tutti convenzionali e non imposti dal compilatore.

// Formatting makes it easier to find bugs

int eggs_yolks =  3;
int      yeast = 15;

int flour=500;int sugar=200;// compact, but difficult to read

Istruzioni

La ragazza di Lucian sta tornando a casa e lui non ha ancora preparato la cena per il loro anniversario!

In questo esercizio, scriverai del codice per aiutare Lucian a cucinare una lasagna squisita tratta dal suo ricettario preferito.

Hai quattro compiti, tutti legati al tempo impiegato per cucinare la lasagna.

1. Definisci il tempo di cottura previsto in minuti

Definisci la funzione ovenTime() che non accetta argomenti e restituisce per quanti minuti la lasagna deve stare in forno. Secondo il ricettario, il tempo di cottura previsto in forno è di 40 minuti:

ovenTime();
// => 40

2. Calcola il tempo di cottura rimanente in minuti

Definisci la funzione remainingOvenTime(int actualMinutesInOven) che accetta come argomento i minuti effettivi di permanenza della lasagna in forno e restituisce per quanti minuti la lasagna deve ancora rimanere in forno, in base al tempo di cottura previsto in minuti del compito precedente.

remainingOvenTime(30);
// => 10

3. Calcola il tempo di preparazione in minuti

Definisci la funzione preparationTime(int numberOfLayers) che accetta come argomento il numero di strati che hai aggiunto alla lasagna e restituisce quanti minuti hai impiegato a prepararla, supponendo che ogni strato richieda 2 minuti di preparazione.

preparationTime(2);
// => 4

4. Calcola il tempo trascorso in minuti

Definisci la funzione elapsedTime(int numberOfLayers, int actualMinutesInOven) che accetta due argomenti: il primo è il numero di strati che hai aggiunto alla lasagna, il secondo è il numero di minuti in cui la lasagna è stata in forno. La funzione deve restituire quanti minuti hai impiegato per cucinare la lasagna, cioè la somma del tempo di preparazione in minuti e del tempo in minuti che la lasagna ha trascorso in forno fino a quel momento.

elapsedTime(3, 20);
// => 26
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
C++ Exercism

Vuoi iniziare Lasagna?

Iscriviti a Exercism per imparare e padroneggiare C++ con 19 concetti100 esercizi e il mentoring di persone reali, tutto gratis.