Costituzione dei gruppi, e inizio della sfida.
Linguaggio C
- Costanti base, numeri interi (545), numeri float (345.45), caratteri ( ‘a’ ), stringhe ( “ciao” ).
- Tipi base: interi, char, short int, int, long, long long, float, double, bool (includere stdbool.h e compilare con -std=c99).
- Dichiariazioni variabili, inizializzazione delle variabili.
- Dichiarazione vettori, uso delle define per definire nomi per valori costanti (esempio: dimensione N del vettore).
- Istruzione di selezione if, (studiare dal libro la switch).
- Istruzione di selezione while e for, (studiare dal libro al do…while).
Esempio:
Dato un vettore di interi V di dimensione N = 100, con valori generati a caso nell’intervallo [0,1000), e dato un valore da leggere da input $$k$$, trovare una coppia di indici del vettore V, tali che la loro somma sia uguale a $$k$$.
[cpp]
// ——– Versione in C, standard C11 ————
// copiate con un editor, salvate e compilate con ‘gcc -std=c99 nome.c -o nome’
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define N 100
#define MAXVAL 1000
int main(void)
{
int v[N] = { 0 }; // non dimenticate di inizializzare SEMPRE.
for (int i=0; i<N; i++) v[i] = rand() % MAXVAL;
// leggiamo k
int k = 0;
printf("Inserisci k: ");
scanf("%d",&k);
// Iniziamo la ricerca:
bool fine = false;
for (int i=0; i<N-1 && !fine; i++)
for (int j=i+1; j<N; j++)
if (v[i]+v[j] == k) {
printf("Trovati i = %d, v[i] = %d, e j = %d, v[j] = %d \n",i,v[i],j,v[j]);
fine = true;
break;
}
if (fine == false) printf("i,j non trovati\n");
return 1;
}
[/cpp]
[python]
# ——– Versione in Python, 3.xx ————–
from random import random
N = 100
MAXVAL = 1000
v = [0]*N
for i in range(N): v[i] = random()*MAXVAL // dove sta l’errore?
k = int(input("Inserisci k: "))
i = 0
finito = False
while (i < N-1):
j = i+1
while (j < N):
if (v[i]+v[j] == k):
print("i = %d, v[%d]=%d, j=%d, v[%d]=%d\n",i,v[i],j,v[j])
finito = True
j+=1
i+=1
print("Finito")
[/python]
Python (Advanced)
Un manuale in Italiano, traduzione del manuale ufficiale di Python 3 si trova al seguente
link.
Questo appunto è un nuovo costrutto di Python, che mostra come sia possibile alzare molto, il livello di astrazione con cui si esprime la computazione. Molto spesso, quando programmiamo, anzi in generale nella risoluzione di qualche problema, dobbiamo lavorare con degli elementi di un insieme S, che gode di qualche proprietà.
Nella matematica questo fatto è molto comune, tanto che esiste una notazione specifica con cui si definiscono, o costruiscono gli insiemi, a partire da insiemi già noti. La forma adottata in matematica per costruire un insieme $$S$$ a partire da uno $$A$$ già noto è generalmente del tipo:
\[ S = \left\{ \;f(x)\; |\; \forall\; x \in A \mbox{ se vale } P(x) \right\} \]
Informalmente S è composto dall’applicazione della funzione $$f$$ a tutti e soli gli elementi di $$A$$ (il nostro insieme di partenza) che soddisfano il predicato booleano $$P$$.
Un esempo concreto, se voglio costruire l’insieme dei cubi dei numeri dispari, posso scrivere:
\[ S = \{\; x^3\; |\; \forall\; x \in N \; \wedge\; x = 2k+1\; \} \]
In Python la costruzione di un insieme come $$S$$ (naturalmente non l’insieme infinito, ma un suo sottinsieme finito) può essere fatta in modo tradizionale, usando i cicli, for o while, in modo opportuno, oppure possiamo usare un espressione chiamata “list comprehension” derivata dai linguaggi di tipo funzionale, che deriva a sua volta, direttamente dalla sintassi più propriamente matematica:
[python]
> A = range(1,10)
# uso di list comprehension:
> S = [ x**3 for x in A if x % 2 == 1 ]
> S
[1, 27, 125, 343, 729]
[/python]
Questo tipo di espressione chiaramente alza notevolmente il grado di astrazione, e la compattezza del codice. Non si faccia però confusione: la sua presenza, non rende il linguaggio più potente, cioè, S resta comunque calcolabile anche senza il suo utilizzo tramite un uso normalissimo del while come visto a lezione.
E’ evidente però, l’eleganza di quel costrutto rispetto al tradizionale ciclo while.