/
esercizi_per_prima_provetta.txt
227 lines (139 loc) · 7.41 KB
/
esercizi_per_prima_provetta.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
[tutti questi esercizi hanno già n soluzioni, pertanto cercate di risolverli per conto vostro prima di googlare]
***esercizio 1
scrivere un programma che fa la copia di un file
il programma prende come parametro a riga di comando:
- il nome del file "sorgente"
- il nome del file "destinazione"
se il file destinazione esiste, "tronca" a zero la sua dimensione (prima di scriverlo).
il programma controlla i risultati di tutte le system call.
esempio: se il file sorgente non esiste, fornisce un messaggio opportuno.
potreste usare le seguenti system call: open, read, write, close
***esercizio 2
scrivere un programma che legge da stdin tutto fino a EOF e conta (separamente) i seguenti caratteri:
\n
' ' (spazio)
ed i caratteri alfabetici minuscoli ('a'-'z')
dopo EOF, scrive su stdout il conteggio dei caratteri.
provare il programma utilizzando il file di testo che potete scaricare qui:
https://github.com/marcotessarotto/exOpSys/blob/master/res/text01.txt
"nome_programma" < text01.txt
***esercizio 3
scrivere la seguente funzione:
int * gen_random_array(unsigned int seed, int use_seed, unsigned int number_elements);
se use_seed è true, utilizza il parametro seed con la funzione srand() per impostare il "seed" della sequenza di interi pseudo-casuali.
number_elements è il numero di celle dell'array che la funzione restituirà
il valore di ogni elemento dell'array è ottenuto invocando rand()
esempio:
gen_random_array(-100, 1, 10) cioè con seed pari a -100 restituisce un array di 10 elementi pari a:
(TODO!!!)
***esercizio 4
scrivere la seguente funzione:
find_max_even_positions() che prende come parametri un array di int e la sua dimensione (numero di celle);
cerca tra le celle in posizione pari quella avente valore massimo e ne resituisce la POSIZIONE (restituisce la prima posizione, in caso di più celle con valore massimo)
es:
per l'array { 0, 100, 7, 50, -45, 10 } restituisce 2 (cioè la posizione della cella che ha valore 7)
***esercizio 5
sono dati due vettori di int, aventi lo stesso numero di elementi array_len
int array1[], int array2[], int array_len
scrivere una funzione join_arrays_same_length che prende i tre parametri sopra e crea e restituisce l'vettore "fusione", costituito da array_len elementi, costruito in questo modo:
l'elemento i-mo di array_fusion è dato dal maggiore tra i due elementi i-mi dei due array.
la funzione restituisce il puntatore all'array fusione.
esempio:
i due array { 10, 100, 1000 } e { 200, -1, 90 } fusi assieme daranno come risultato:
{ 200, 100, 1000 }
****esercizio 6
per svolgere questo esercizio, occorre avere risolto esercizio 3 ed esercizio 5
provare le due funzioni scritte sopra in questo modo:
usare gen_random_array() con seed = 10 (e use_seed impostato a vero) per generare un vettore di 100 elementi
usare di nuovo gen_random_array() con seed = 20 (e use_seed impostato a vero) per generare un vettore di 100 elementi
usare join_arrays_same_length per generare il vettore "fusione".
scrivere in un file di testo denominato "prova.txt" i valori del vettore fusione, in formato testo:
esempio del contenuto del file prova.txt (i numeri non c'entrano con il valore atteso, servono soltanto ad illustrare il formato del file):
2131
-344
321
0
44541
....
una volta generato il file prova.txt, da shell eseguire il comando:
md5sum prova.txt
questo restituirà il valore:
(TODO!!!)
****esercizio 7
leggere dal file numeri.txt tutti i numeri in un array; non fare ipotesi sul numero di numeri contenuti nel file
fare il sort per valori crescenti (con algoritmo di sorting... quello che volete oppure bubble sort, anche se non è "efficiente": https://github.com/marcotessarotto/exOpSys/blob/master/004.5bubble-sort/bubble-sort.c )
scrivere l'array ordinato nel file numeri_ordinati.txt
per leggere il file linea per linea, potete usare l'esempio https://github.com/marcotessarotto/exOpSys/tree/master/004.2.8read-lines-lseek
il contenuto del file numeri.txt è il seguente:
5
4
3
2
1
0
-1
-2
-3
-4
-5
<fine file numeri.txt>
risultato atteso nel file numeri_ordinati.txt:
-5
-4
....
****esercizio 8
scrivere un programma che legge da stdin tutto fino a EOF
il programma prende come parametro di riga di comando una stringa di caratteri;
il programma cerca la stringa di caratteri fornita in tutto il contenuto letto da stdin e scrive su stdout il numero
di occorrenze della stringa.
provare il programma utilizzando il file di testo che potete scaricare qui:
https://github.com/marcotessarotto/exOpSys/blob/master/res/text01.txt
"nome_programma" ipsum < text01.txt
il risultato è 4.
****20210409****
****esercizio 9****
usare l'esempio:
https://replit.com/@MarcoTessarotto/find-substring
typedef char * char_p;
struct risultato_ricerca {
int numero_occorrenze; // dimensione del vettore posizione_occorrenza
char_p * posizione_occorrenza; // vettore delle occorrenze; ogni occorrenza è riportata nel vettore
// posizione_occorrenza è un vettore di char_p (o char *)
};
scrivere la funzione che restituisce tutte le occorrenze di substr in str:
struct risultato_ricerca trova_occorrenze(char * str, char * substr);
****esercizio 10****
è dato un array di int chiamato int_array di dimensione int_array_len.
scrivere la funzione che inserisce il valore val alla posizione insert_position (cioè le celle dalla posizione insert_position in poi vengono spostate verso destra di una posizione per fare spazio al nuovo valore)
int * insert_into_array(int * array, int array_len, int val, int insert_position)
se insert_position < 0 || insert_position > int_array_len la funzione restituisce NULL
se insert_position == int_array_len, il valore da aggiungere viene messo in coda all'array
la funzione restituisce l'indirizzo dell'array modificato
es:
int int_array[] = {0,1,2,3,4,5};
int int_array_len = 6;
int * result = insert_into_array(int_array, int_array_len, -1, 3);
// insert_into_array restituisce un array di dimensione 6+1 fatto così:
// {0,1,2, -1, 3,4,5}
// insert_into_array(int_array, int_array_len, -1, 0);
// {-1, 0,1,2,3,4,5}
// insert_into_array(int_array, int_array_len, -1, 6);
// {0,1,2,3,4,5,-1}
****esercizio 11****
usare l'esempio:
https://replit.com/@MarcoTessarotto/get-load-average
scrivere un programma in C che faccia quanto segue:
il programma prevede come parametri a linea di comando due valori (int):
numero di cicli (default: 10)
intervallo (secondi) (default: 5)
se i parametri non sono forniti, usare i valori di default indicati sopra.
crea il file log.txt per scriverci di dati ottenuti sotto; il file viene sovrascritto, se esiste già.
per 'numero di cicli' volte, a distanza di 'intervallo' secondi, rileva il 'load average over 1 minute' (vedi getloadavg() ed esempio fornito);
ad ogni interazione scrive il valore in formato testo all'interno di un file 'log.txt'.
alla fine del ciclo:
- il processo padre crea un processo figlio che calcola e scrive su stdout il valor medio dei valori di 'load average over 1 minute' ottenuti nel ciclo sopra
- il processo figlio scrive il valor medio calcolato in un file 'result.txt' ; il numero è scritto in formato testo
- il processo padre aspetta la terminazione del processo figlio; poi legge il valore calcolato dal processo figlio dal file 'result.txt'
seconda parte dell'esercizio:
il processo padre fa il sort crescente dei valori rilevati nel ciclo principale;
poi inserisce il valore medio calcolato dal processo figlio nella posizione opportuna dell'array ordinato, per mantenere l'ordinamento del nuovo array.