Fuck you Pascal

Home

2012-06-22T10:19:00.003+02:00

Pascal's HOME

" Writeln ('Benvenuto/a');

Readln; "

-Cit. Pascal Array (1968-69)

Un fottuto saluto a tutti voi.

Nel 2011 ho creato questo blog perché come ben sappiamo il nostro carissimo professore-automa a stati finiti ha unicamente la funzione basilare di cliccare un tasto per far scorrere le slide...
Poi secondo me non le legge nemmeno con la sua voce... (Usa Eloquence e mima il parlato con la bocca).
Quindi, il blog è stato fondamentalmente creato per portare alla luce questi misteri creati unicamente dalla sua cripticità intrinseca e alla sua "voglia di vivere".
Se seguite bene questa semplice guida (insieme ad esercizio costante) vi assicuro una riuscita del 100% della prova. Le lezioni sono 7 in tutto e sono state create per portare chiarezza su questo linguaggio, che nella vita non vi servirà ad una beata cippa, ma che anzi, vi farà crollare l'autostima del 79% (Statistiche del professore) e vi farà avere pensieri suicidi.
Vi invito a mettere mi piace su Facebook se questa guida è o è stata utile.

Che cosa stai aspettando? Vai all'indice ed esplora la guida!

Ti auguro buona fortuna.

SE QUESTO BLOG TI PIACE, FAMMELO SAPERE!!!
Cliccando qui sotto.

Settima Lezione

2011-12-04T19:33:00.000+01:00

Introduciamo un altro elemento utile per evitare la perdita di tempo nello scrivere molte variabili.

Grazie alla collaborazione (totale) di Patrizia Mel Marinelli in questa sesta lezione capiremo come si comporta questa variabile.

L'array non è altro che uno spazio di memoria dove possiamo inserire e "conservare" più elementi senza dover dichiarare un numero di variabili elevato.
Questo è un grande vantaggio, infatti, con lo stesso nome si indica una lista di elementi (più o meno lunga a seconda del numero delle caselle specificate), ognuno dei quali è accessibile singolarmente. Cosa significa?

Dopo aver inserito tutti gli elementi nel mio nuovo array, posso accedere al primo elemento, così come all'ultimo, o al terzo in maniera del tutto autonoma e semplificata, come se registrassi tutti i dati in una tabella figurata del genere:

Insomma, posso operare su qualsiasi elemento io voglia la dichiarazione di una variabile array(detta in gergo vettore).

La stesura dell'array è applicata in questo modo:

Var A :array[1..n] of "tipo di dato";
(dove n è il numero massimo dei dati che si vogliono inserire ed il tipo di dato può comprendere ogni genere di variabile fino ad ora studiato).
Ad esempio, la schematizzazione in alto potrebbe essere scritta così:

Var A : array[1..8] of integer;

A sarà il nome della mia array e [1..n] sarà il numero di elementi che potrà contenere il mio vettore. Il tipo di dato sarà quello che il mio vettore sarà in grado di contenere.
Abbiamo appena visto un vettore di tipo integer, ma nulla ci vieta di fare un' array di tipo char o string, o anche real, insomma questa specie di "contenitore" ci semplifica la vita un bel po'!
L'importante è sapere come si identifica un qualsiasi elemento dell'array.
Bene, supponiamo di avere il nostro vettore A, per identificare un elemento del vettore è necessario scrivere in questo modo A[1], A[2], A[3] ecc...
La cosa fantastica è che il numero tra parentesi quadre detto anche "indice" dell'elemento, può essere qualsiasi cosa!
Mi spiego meglio: Posso scrivere A[i] (nel caso di un ciclo "for,to"), A[length(x)] nel caso di una stringa A[b+1], A[b-1], A[2*2].

Gli array si usano di solito quando dobbiamo lavorare su un numero abbastanza elevato di elementi, in sostanza quando devo inserire dei dati e poi fare delle operazioni sui singoli dati.

In parole povere quando devo tenere memoria di tutto quello che ho inserito perché semplicemente "mi serve dopo", nulla mi vieta di utilizzare 100 variabili diverse, o 10 variabili diverse, ma avere una variabile sola che identifica con un indice 100 elementi differenti è una bella comodità.

Patrizia Mel Marinelli

Dopo questa spiegazione impeccabile di Patrizia, dovreste essere entrati un po’ di più nella meccanica delle Array e di Pascal, quindi credo che siate pronti per qualche esercizio con spiegazione:

Successivo.

Precedente.

Sesta Lezione

2011-12-04T18:17:00.000+01:00

If, then, else.
In questa lezione introduciamo un nuovo comando e poche altre cose:
Il nuovo comando è chiamato If,then,else.

La "If, then, else" permette di creare una ramificazione al nostro programma, come in esempio, dopo l'istruzione se per un certo motivo l'operazione corrisponde alla then, allora inizia un istruzione, se invece non è così subentra l'else che svolge un'altro tipo di operazione. La else non è necessaria, infatti se ad esempio vogliamo un programma che inizi solo per un certo parametro "If,then", senza la seconda condizione possiamo anche scartarla.
Naturalmente le due End, mi daranno soluzioni diverse.
Adesso facciamo un esempio semplice di come implementare questa operazione molto semplicemente con un programma che una volta inserito un numero, ci dice se è positivo o se è negativo.

Program pos_neg;

Var

x : integer;

Begin

Write ('Digita un numero: ');

Readln (x);

If x<>0 then;

If x>0 then Write ('',x,' corrisponde ad un numero positivo')

else Write ('',x,' corrisponde ad un numero negativo');

Readln;

End.

Andiamo ad analizzare il contenuto:

Abbiamo inserito un'unica variabile che conterrà un valore.

La prima if è essenziale, poiché specifica che se il valore è diverso da 0, il programma può continuare con la If,then,else che specifica il numero positivo o il numero negativo.

La if, then, else dice proprio letteralmente al programma:

Se x è maggiore di 0, allora scrivi (numero positivo), in caso contrario (else, che in questo caso significa matematicamente x<0) scrivi (numero negativo).

Il programma si esegue in questo modo:

Se digitiamo un valore positivo, o

Se digitiamo un valore negativo.

Niente di più semplice.

Successivo.

Precedente.

Quinta Lezione

2011-12-04T14:55:00.000+01:00

In questa quinta lezione analizzeremo alcune caratteristiche delle variabili che introdurrò oggi, ovvero:

real
char
string

Real.
Partiamo dal primo, il valore real. Questo valore è molto più vasto del valore integer, in quanto è un contenitore che può assumere tutti i valori numerici reali. Un esempio di utilizzo di questo genere di variabile è questo, un programma che fa la media di due numeri (sapendo che la media di due numeri è la divisione per due della loro somma).

Program med_num;
Var
a,b : integer;
med : real;
Begin
Write ('Scrivi il primo numero: ');
Readln (a);
Write ('Scrivi il secondo numero: ');
Readln (b);
med := (a+b)/2;
Writeln ('La media dei numeri corrisponde a ',med,'');
Readln;
End.

Abbiamo impostato la media come valore reale, otterremo quindi questo risultato:

Il numero della media, anche se per noi non comprensibile istantaneamente, è un numero matematicamente corretto. Per avere un risultato numerico più vicino alla matematica di un semplice calcolatore, bisogna scrivere nell'ultima Writeln in questo modo:

Writeln ('La media dei numeri corrisponde a ',med:0:2,'');

Scrivendo :0:2 dopo la variabile "med", si specifica che voglio avere in output un risultato che abbia solo un numero prima della virgola ("0") e due numeri dopo la virgola ("2"):

Se avessi voluto avere 4 numeri dopo la virgola, avrei scritto così "med:0:4".
E questa era la condizione di variabile con real, passiamo alla condizione char.

Char.
Come già spiegato in precedenza assume il valore di una lettera, ecco ad esempio un programma che memorizza e manda in output una lettera:

Program lettera;
Var
x : char;
Begin
Write ('Scrivi una lettera: ');
Readln (x);
Readln;
Write ('La lettera inserita corrisponde ad "',x,'"');
Readln;
End.

Perfetto, in basso riporto un esempio di funzionamento del programma:

Come si vede, il programma memorizza la lettera "A" nella variabile "x" e così in output, otterrò come risultato la lettera che ho scritto. Ma cosa succede se invece di "A", scrivessi una parola, come "America"?:

Il programma mi restituisce solo la prima lettera digitata, "A" in quanto char è un contenitore di una sola lettera. Come fare?
Per ovviare a questo problema mi serve un'altra variabile.

String.
String è un contenitore di "parole", fa proprio al caso nostro per l'esercizio di prima. Basta sostanzialmente correggere la variabile da char in string e il gioco è fatto:

Program parola;
Var
x : string;
Begin
Write ('Scrivi una parola: ');
Readln (x);
Readln;
Write ('La parola inserita corrisponde ad "',x,'"');
Readln;
End.

Constatiamo il funzionamento del software con questi esempi:
Esempio 1.

Esempio 2.

Bene, ora conosciamo altre 3 variabili, nel prossimo capitolo seguiranno diverse applicazioni di queste ultime. Vi invito a fare delle domande per eventuali incomprensioni e spero di essere stato chiaro fino ad ora.

Fine della Quinta lezione.

Successivo.

Precedente.

Quarta Lezione

2011-12-04T01:16:00.000+01:00

Il secondo modo di realizzare un ciclo è la While, do.
Questo metodo è leggermente più elaborato del primo, ed è decisamente poco usato, ma vi potrà essere molto utile. Iniziamo subito con la stesura del programma:

Program Somma_tre;
Var
k : integer;
a,tot : integer;
Begin
k:=1;
a:=0;
tot:=0;
While k <=3 do
Begin
Write ('Digita un numero: ');
Readln (a);
tot:=(tot+a);
k:= (k+1);
End;
Writeln ('La somma dei numeri corrisponde a: ',tot,'');
Readln;
End.

Analizziamo subito il programma. Per molti aspetti non si discosta molto dal primo. Le uniche sostanziali variazioni sono la sostituzione del for,to,do al While, do e abbiamo anche specificato che all'inizio la variabile "k" assume il valore di 1. Oltre a questo, nell'algoritmo che sarà ripetuto ciclicamente (quello tra il secondo Begin e il primo End;) ogni volta che abbiamo una ripetizione, "k" incrementa il suo valore di 1 (ed è proprio per questo che quando k diventa uguale a 4 il ciclo si interrompe, perché non rispetta più il valore k<=3).
Il valore nella While, do sta a dire proprio "Finché k è minore o uguale a 3 allora ripeti l'operazione".
Al terzo inserimento, "k" raggiungerà il valore 4, chiudendo così il ciclo.
Ecco come funziona:

Il procedimento è uguale a quello della terza lezione, solo che questa volta imponiamo che finché k è minore o uguale a 3 il ciclo si ripeterà. Ebbene, a ogni fine istruzione "k" diventa "k"+1, cioè incrementa il suo valore di 1. Basteranno 3 ripetizioni per raggiungere il valore 4 e uscire dal ciclo.

Detto questo, ora sei in grado di risolvere un'esercizio con un ciclo a tua scelta tra il For,to,do e il While,do:
Esercizio n° 2.
>Crea un programma che moltiplichi 9 numeri. (Prova a farlo con tutti e due i metodi).

L'operazione While,do non si limita soltanto a eseguire delle ripetizioni numerate, ma permette anche di creare un programma in grado di scrivere quanti numeri si vuole per poi eseguire con questi una determinata operazione. Vediamo l'esempio:

Program Somma_n;
Var
a,tot : integer;
Begin
a:=1;
tot:=0;
While a<>0 do
Begin
Write ('Digita numero [0 per terminare]: ');
Readln (a);
tot:=(tot+a);
End;
Writeln ('Il totale corrisponde a: ',tot,'');
Readln;
End.

La While recita proprio <Finché "a" è diversa da 0, allora ripeti il ciclo>
Quando si inserisce 0 nella variabile "a" il ciclo termina e il programma da il risultato dei numeri inseriti:

Sono stati inseriti dei numeri nel programma, e se il valore non è zero, il ciclo continua all'infinito. Quando si vuole terminare il calcolo, non si fa altro che digitare 0 come valore.

Un' altra variante di questo esercizio, ovvero di creare un programma in grado di fare operazioni similari con un certo numero di numeri (scusate il gioco di parole) è questo:

Program Somma_numeri;
Var
k : integer;
x,tot : integer;
n : integer;
Begin
Writeln ('Benvenuto nel programma di somma, premi INVIO per continuare');
Readln;
Write ('Quanti numeri vuoi sommare?: ');
Readln (n);
k :=1;
x :=0;
while k <=n do
Begin
Write ('Digitare il valore ',k,': ');
Readln (x);
tot := tot+x;
k := k+1;
End;
Writeln ('La somma corrisponde a ',tot,'');
Write ('Premi INVIO per continuare');
Readln;
End.

Non sarà il programma che rivoluzionerà il mondo, ma ha la sua dose di buona interfaccia per una corretta comprensione dell'utente che lo usa.
E' la stessa cosa del ciclo di While, solo che in questo caso è l'utente a decidere quanti numeri vuole sommare, grazie alla variante "n" che sostituisce il numero predefinito di ripetizioni.
Una volta superato il numero "n" il ciclo terminerà lasciando il risultato.
Per una migliore comprensione sono stati aggiunti anche dettagli sullo starter del programma, che si da con un semplice comando di INVIO e una fine correlata con il risultato che indica all'utente che per terminare la sessione deve premere INVIO.
Ecco come funziona il programma, ad esempio voglio sommare 5 numeri:

Bene, come avete notato, dopo "Digitare il valore" vi è il numero progressivo della variante "k" che incrementa di un numero ogni volta che si ripete l'operazione, ed è per questo che è ottima per farne derivare il numero dell'operazione. La ripetizione perpetua di "Digitare il valore" diventa "Digitare il valore 1", "Digitare il valore 2" e così via.
Fine della Quarta Lezione.

Terza Lezione

2011-12-03T21:43:00.000+01:00

E' stato difficile fare un programma che sottraesse tre numeri?
Di sicuro avete speso molto tempo nello scrivere tutto, si, forse difficile, ma non impossibile:

Program Sottrazione_tre;
Var
a,b,c : integer;
k : integer;
Begin
Write ('Scrivi il primo numero: ');
Read (a);
Write ('Scrivi il secondo numero: ');
Read (b);
Write ('Scrivi il terzo numero: ');
Read (c);
k:= (a-b-c);
Writeln ('La sottrazione corrisponde a :',k,'');
Readln;
Readln;
End.

Ecco la soluzione, niente di difficile. Ma cosa dovremmo fare se ci si presentasse una traccia del genere?:
>Si realizzi un programma che sommi 100 numeri.
Di certo perderemmo ogni senno, ogni residua ragione se dovessimo scrivere 100 writeln e 100 readln.

Ed è per questo che possiamo implementare un ciclo:
Che cos'è un ciclo?
Un ciclo è un'operazione perpetua che continua finché non raggiunge un certo numero prestabilito, finchè diciamo rispetti una condizione che poniamo in precedenza.
Es: Continua a ripetere la stessa istruzione di somma finché i valori non rispettano la condizione in pieno.
Schematizzando possiamo ottenere questo:

Schema Ciclo

In questo schema, si intuisce che innanzitutto sono presenti due Begin, uno in cui sono contenute le condizioni, in questo caso, usando un po di immaginazione, le condizioni ci dicono che le istruzioni in basso, dopo il secondo Begin, vanno ripetute 3 volte.

Una volta esaurite le condizioni, ovvero, appena le istruzioni sono state fatte per la terza volta in questo caso, il ciclo si interrompe perché ha rispettato tutte le condizioni e si ha così il risultato finale che, in un programma di somma, può essere la somma di 3 numeri, o in un programma di moltiplicazione, la moltiplicazione di 3 numeri.

Questa è soltanto un'immagine grafica per capire cosa fa il programma durante il ciclo, ora proviamo a scrivere un programma che riesca a fare la somma di 3 numeri, utilizzando un ciclo.
Ci sono due metodi per implementare un ciclo:

La condizione For to do.
La condizione While do.

Esaminiamo la prima.
For, to, do, è usato principalmente per implementare un ciclo, ed è molto semplice da usare, ad esempio, vogliamo la nostra condizione nella quale bisogna ripetere questo:
Write ('Scrivi il numero: ');
Readln (a);
Per 3 volte come da traccia. Ebbene, tra il primo e il secondo begin scriveremo questa condizione:
For k:=1 to 3 do
Dove k è una variabile integer che abbiamo inserito all'inizio.
Esaminiamo il programma completo:

Program Somma_tre;

Var
k : integer;
a,tot : integer;
Begin
a:=0;
tot:=0;
For k:= 1 to 3 do
Begin
Write ('Digita un numero: ');
Readln (a);
tot:=(tot+a);
End;
Writeln ('La somma dei numeri corrisponde a: ',tot,'');
Readln;
End.

Come di norma, analizziamo tutto il contenuto:
Abbiamo inserito una variabile k (integer) che svolgerà la variabile del ciclo, poi un'altra variabile "a" (che sarà ripetuta 3 volte) in cui digiteremo tutti e tre i numeri della somma ed un'altra, "tot" che sarà il contenitore della somma e anche il primo addendo all'interno del ciclo.
Nel primo Begin, specifico che il valore attuale di "a" e di "tot" corrispondono a 0 per il momento (sono variabili ed è proprio per questo che hanno la proprietà di variare nel tempo). Poi inserisco la condizione For, to, do e specifico per "k" da 1 a 3 fai la stessa operazione.
Parte il secondo Begin che termina con un primo End con il punto e virgola. Tra questi due è racchiusa l'istruzione che sarà ripetuta 3 volte, ovvero di digitare la variabile "a" e l'istruzione che il totale è uguale all'attuare totale ("tot") + "a";
Dopo il primo End, Scriviamo l'operazione per visualizzare la somma e terminiamo con un secondo End.
Il programma svolge questo:

Vediamo cosa accede passo per passo nel programma:

La variabile "k" è valida da 1 a 3, dopo il 3, il ciclo si interromperà. Si inserisce il primo numero nella variabile "a", in questo caso 4, l'istruzione del secondo Begin ci dice che il totale "tot" è uguale a "tot" + "a", e per questo, visto che all'inizio, nel primo begin era scritto che il tot:=0, ne consegue che il programma eseguirà questa operazione:
tot = 0("tot") + 4("a"). Adesso il totale è uguale a 4. La variabile "k" non è ancora soddisfatta, quindi l'operazione tra il secondo Begin e il primo End si ripete per la seconda volta. Inserendo un'altra volta la "a" con il valore 7, avremmo che il tot ora è uguale a 4(primo "tot") + 7("a"). Ora il tot è uguale a 11, e questo accadrà anche quando il ciclo si ripeterà per la terza ed ultima volta (11+3=14).
Questo era il ciclo con il For, il to e il do, nella quarta lezione vi mostrerò come fare un ciclo con While e do.
Fine della Terza lezione.

Seconda Lezione

2011-12-03T17:36:00.000+01:00

Eccoci giunti alla seconda lezione, dove capiremo come si possono sfruttare le operazioni.
Niente di più semplice.
Le operazioni sono delle formule tra variabili (spiegate nella prima lezione).
La stessa operazione (come la somma, la moltiplicazione, la divisione) è indicata come variabile ed è specificata all'interno del programma.
Ora vediamo un semplice programma di somma tra 2 numeri:

Program Somma_numeri;

Var

a,b : integer;

tot : integer;

Begin

Write ('Scrivi il primo numero: ');

Readln (a);

Write ('Scrivi il secondo numero: ');

Readln (b);

tot:= (a+b);

Write ('La somma corrisponde a ',tot,'');

Readln;

End.

Ebbene, analizziamo l'esempio riga per riga:

Nella prima, come sempre si specifica che quello che sto scrivendo è un programma, poi si digita il nome.
Nella seconda inserisco il comando Var, per poi in seguito inserire le variabili.
Inserisco solo le variabili che mi servono, come "a" che conterrà il mio primo numero di imput e "b" che conterà il secondo e assegno il valore di numero intero (con integer);
Inserisco una terza variabile che farà da contenitore del risultato, ovvero "tot".
Impartisco al programma il comando begin per iniziare il programma sempre dopo le variabili.
Write non è essenziale, poiché avrei potuto solo scrivere il primo numero, serve solo a far capire a chi utilizza il programma cosa deve fare per andare avanti.
Read (a); serve per digitare il numero, e così anche Read (b);
Siamo alla decima stringa, quella essenziale. Grazie al comando inserito nella stringa il programma capisce che il totale (la nostra variabile "tot") è uguale alla somma di "a" e di "b".
Infine Scriviamo che il numero è corrispondente a "tot" come abbiamo già visto in precedenza, con questo metodo: Write ('Text ',var,'');
Mettiamo un read per non terminare il programma senza aver visualizzato il risultato.
Ed ecco infine il comando End. che termina la sessione.

Il programma funziona così:

Sapendo questo, ora potresti riuscire a creare un programma che riesca a fare operazioni diverse dalla somme, come ad esempio un programma di sottrazione, sostituendo
tot:= (a+b) con tot:=(a-b).
Ora le operazioni che puoi fare sono la moltiplicazione, la divisione, la somma e sottrazione.

Esercizio 1.
>Conoscendo questo, prova a creare un programma che faccia la sottrazione di tre numeri.
(Soluzione in Terza lezione).

Fine della Seconda lezione

Successivo
Precedente

Prima Lezione

2011-12-02T19:16:00.000+01:00

Questa è la prima lezione del programma Pascal, (quella famosa lezione fondamentale che riesce a farti capire qualcosa sul funzionamento e a che cazzo serve). Se pensi che non sia necessaria per la tua preparazione, puoi anche saltarla e andare direttamente alla seconda lezione.
Ebbene, il Pascal è un linguaggio ~~inutile e di merda~~ avanzato che permette di costruire o programmare un qualsiasi programma, infatti il programma in se sa svolgere delle basilari operazioni di calcolo.
Con pascal è possibile creare anche giochi ad altissima definizione come il Tetris!
Si, è proprio questo che ci fa intuire che stiamo studiando un programma del secolo scorso, un punto in più per la teoria che in Italia siamo dei retrogradi!

Come detto in Pascal si possono fare delle operazioni molto basilari.
Conoscere il linguaggio è essenziale:

Iniziando un programma bisogna scrivere in partenza il comando: Program , in seguito, dopo uno spazio scriveremo il nome che vogliamo assegnare al programma che sarà uno a nostra scelta, possiamo scrivere una lettera, come una parola, ma non possiamo usare spazi nel nome ed è per questo che si usano i trattini bassi. Alla fine si deve mettere il punto e virgola.
Nel programma possono essere presenti le variabili, che sono contenitori numerici, di lettere, di parole che hanno appunto la proprietà di cambiare durante il programma. Per usare una variabile dopo il comando Program, accapo si scrive Var . Le possibili variabili sono molteplici, ma elenco solo quelle essenziali per il momento:

integer (un numero intero)
real (un numero reale)
char (un carattere come ad esempio "p")
string (una stringa di caratteri)

Il programma inizia il suo funzionamento con l'istruzione Begin che permette appunto di mandare in esecuzione il programma.
Altri due comandi sono
Write ('Testo');
nel quale è possibile inserite un testo che sarà mandato in output sullo schermo e
Read;
Con il quale sarà possibile leggere il testo scritto o inserire un numero in un contenitore indicato nel comando Var .

Dopo saranno specificate tutte le funzioni e gli algoritmi che devono essere effettuati fino all'istruzione End. che termina in modo definitivo il programma.
Adesso vi mostro il primo esempio di un programma elementare con variabili:

Program Scrivi_numero; ---------> il punto e virgola va specificato
Var ----------> il punto e virgola non va specificato
a : integer; ---------> il punto e virgola va specificato
Begin ----------> il punto e virgola non va specificato
Write ('Inserisci un numero'); ---------> il punto e virgola va specificato
Read (a); ---------> il punto e virgola va specificato
End. ----------> il punto è necessario

In questo programma si specifica che la variabile è la lettera a, grazie al comando Var ed in seguito con Begin si inizia il programma dove la Write chiede di inserire un numero (potevamo anche scrivere inserisci un cazzo di numero) e si noti che la scritta tra parentesi è chiusa tra apici per il testo. Poi si ha la Read che mi dice che il numero che inserirò va inserito direttamente nella variabile che ho scritto in precedenza venendo così salvato.

Il programma finisce salvando per una frazione di secondo il numero che ho inserito, poiché quando la sessione è terminata con la End. il programma chiudendosi perde tutti i dati assimilati.
Ma se volessi visualizzare il numero che ho scritto, come dovrei fare?:

Program Scrivi_numero;
Var
a : integer;
Begin
Write ('Inserisci un numero: ');
Read (a);
Writeln;
Readln;
Write ('Il numero inserito corrisponde a: ',a, '')
Readln;
End.

Il programma si eseguirà così:

La sostanziale differenza tra Write, Read e Writeln e Readln è che questi ultimi dicono al programma di andare daccapo infatti, nel programma se invece della prima Write scrivessi Writeln, il valore sarebbe digitato daccapo:

il Writeln e il Readln vuoti mi danno uno spazio tra il primo e il secondo testo.
L'ultimo Readln; serve a leggere la Write superiore, nell'ultima Write abbiamo visualizzato il numero che abbiamo inserito tramite le virgole che circondano la "a" che servono a far capire al programma che si tratta proprio di quel contenitore in cui abbiamo appena inserito il numero.
Molte operazioni possono essere effettuate tra le varianti per ottenere diverse formule, le principali sono:

+, -, *, / Sono i valori di somma, sottrazione, moltiplicazione e divisione.
> Indica che una variabile è maggiore di un' altra.
< Indica che una variabile è minore di un' altra.
= Indica che una variabile è uguale ad un' altra.
>= Indica che una variabile è maggiore o uguale ad un'altra.
<= Indica che una variabile è minore o uguale ad un'altra.
<> Indica che una variabile è diversa da un'altra.

Queste sono le principali operazioni, e possono essere effettuate sia tra variabili che tra numeri digitati.

Fine della prima lezione.