AP1 2017-09-22

p1.cc

#include <iostream>
using namespace std;


// La funció maxim, donats dos enters retorna un enter que és el seu màxim.
int maxim(int a, int b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}


// Programa que llegeix dos enters i n'escriu el seu màxim, cridant maxim().
int main() {
    int x, y;
    cin >> x >> y;
    cout << maxim(x, y) << endl;
}

p2.cc

#include <iostream>
using namespace std;


// La funció maxim, donats dos enters retorna un enter que és el seu màxim.
int maxim(int a, int b) {
    if (a > b) return a;
    else return b;
}


// La funció maxim3, donats tres enters retorna un enter que és el seu màxim.
int maxim3(int a, int b, int c) {
    return maxim(a, maxim(b, c));
}


// Programa que llegeix tres enters i n'escriu el seu màxim, cridant maxim3().
int main() {
    int x, y, z;
    cin >> x >> y >> z;
    cout << maxim3(x, y, z) << endl;
}

p3.cc

#include <iostream>
using namespace std;


// La funció power(x, y) retorna x^y, donat que y>=0.
int power(int x, int y) {
    int p = 1;
    int i = 0;
    while (i < y) {
        p = p * x;
        i = i + 1;
    }
    return p;
}


// Programa que llegeix dos nombres i eleva el primer al segon.
int main() {
    int x, y;
    cin >> x >> y;
    cout << power(x, y) << endl;
}

p4.cc

#include <iostream>
using namespace std;


// La funció primer(n) retorna si el natural n és o no un nombre primer.
bool primer(int n) {
    if (n <= 1) return false;
    // Mira si algun nombre entre 2 i n-1 divideix n:
    int c = 2;
    while (c < n) {
        if (n % c == 0) return false;
        c = c + 1;
    }
    return true;
}


// Programa que llegeix un natural i diu si és primer o no.
int main() {
    int n;
    cin >> n;
    if (primer(n)) cout << "si" << endl;
    else cout << "no" << endl;
}

p5.cc

#include <iostream>
using namespace std;


// La funció primer(n) retorna si el natural n és o no un nombre primer.
bool primer(int n) {
    if (n <= 1) return false;
    // Mira si algun nombre entre 2 i √n divideix n.
    int c = 2;
    while (c*c <= n) {      // equivalent a c ⩽ √n   (look ma... no reals! 😄)
        if (n % c == 0) return false;
        c = c + 1;
    }
    return true;
}


// Programa que escriu tots els primers entre 0 i un nombre donat.
int main() {
    int n;
    cin >> n;
    int i = 0;
    while (i <= n) {
        if (primer(i)) cout << i << endl;
        i = i + 1;
    }
}

p6.md

Els booleans

El tipus bool serveix per representar valors lògics, també anomenats booleans. Només hi ha dos possibles valors, fals i cert, que en C++ es representen amb els literals false i true i en Python amb els literals False i True.

Hi ha dues operacions binàries (és a dir, amb dos operands) fonamentals: la disjunció (amb l'operador or) i la conjunció (amb l'operador and). També hi ha una operació unària (sobre un sol booleà): la negació (amb l'operador not). Les taules de veritat següents mostren tots els resultats possibles d'aquestes operacions.

• Taula de veritat de la negació:

a	not a
false	true
true	false

• Taula de veritat de la disjunció:

a	b	a or b
false	false	false
false	true	true
true	false	true
true	true	true

• Taula de veritat de la conjunció:

a	b	a and b
false	false	false
false	true	false
true	false	false
true	true	true

També es pot comprovar si dos booleans són iguals, o si són diferents amb els operadors == i !=, però això és mal estíl, ja que són innecessaris. Per exemple, si trobat és un booleà, el fragment

bool trobat = ... ;
if (trobat == true) ...

es millor rescriure'l aixi:

bool trobat = ... ;
if (trobat) ...

Similarment,

if (trobat == false)

és pitjor estil que

if (not trobat)

També, és confús utilitzar identificadors negats per a les variables booleanes: És més senzill entendre la condició gela que not no_gela.

Lleis de De Morgan

Les lleis de De Morgan son un parell de transformacions fonamentals de fórmules que són essencials a l'hora de raonar en informàtica. Escrita en C++, la primera llei de De Morgan estableix que not (a or b) és equivalent a (not a) and (not b). La segona llei estableix que not (a and b) és equivalent a (not a) or (not b). La demostració d'ambdues lleis és ben senzilla utilitzant taules de veritat.

Així, podem veure que el contrari de "gela i és fosc" és "no gela o no és fosc", i no pas "no gela i no és fosc".

Ús dels booleans

Fixeu-vos que ja utilitzaveu els booleans sense saver-ho: El resultat dels operadors relacionals (<, <= , ==, !=, >= i >) és un bool! I les condicions que s'escriuen als ifs i whiles han de ser de tipus boolèa.

Operadors alternatius obsolets

Per compatibilitat amb el llenguatge C, del qual C++ és una evolució, els operador not, or i and també es poden escriure !, || i &&, respectivament. Però com que aquests signes són menys intuïtius i menys llegibles, no és recomanable usar-los.