Tema 2 - Unix Timestamps

• 23 Dec 2023 20:35: update schelet de cod typos
• 13 Ian 2023 23:55: adaugat teste pt taskurile 1-8 t2_tests_1-to-8.zip
• 14 Ian 2023 00:55: corectat testele pt taskul 8
• 15 Ian 2024 02:56: adaugat checker t2_checker.zip (thanks Cosmin & Mihnea & Teo pentru debugging la checker noaptea ca hotii)
• 15 Ian 2024 19:57: update checker + reparat teste task 9
• 15 Ian 2024 21:49: update teste sa fie timezone-urile de max 4 caractere

• Alin Popa

Termen de predare:

• Deadline soft: Joi 11 Ianuarie 2024, 23:55
• Deadline hard: Duminica 14 Ianuarie 2024, 23:55

Pentru fiecare zi (24 de ore) de întârziere, se vor scădea 10 puncte din nota acordată, până la atingerea deadline-ului hard.

Dacă aveți nelămuriri, puteți să ne contactați pe forumul dedicat temei de casă nr. 2 sau pe canalul Temei 2.
Nu se acceptă întrebări în ultimele 24 de ore înainte de deadline.

Ne propunem să construim un sistem care simulează Epoch Converter.

Un Unix Timestamp este un mod standardizat de reprezentare a unui moment în timp, foarte folosit în multe aplicații, framework-uri, și sisteme de operare. Un Unix Timestamp este definit ca numărul de secunde care au trecut de la 1 ianuarie 1970, ora 00:00:00 (in timezone-ul UTC, fostul GMT, numit popular și “ora Angliei”).

Pentru această temă trebuie să porniți de la scheletul de cod de aici: tema2_schelet.zip.

Implementați în fișierul timelib.c funcția:

TTime convertUnixTimestampToTime(unsigned int timestamp)

Funcția trebuie să returneze ora, minutul și secunda corespunzatoare timestamp-ului primit, sub forma unei structuri TTime:

typedef struct {
    unsigned char hour;
    unsigned char min;
    unsigned char sec;
} TTime

timestamp=0 => hour=0; min=0; sec=0
timestamp=3659 => hour=1; min=0; sec=59
timestamp=1703201916 => hour=23; min=38; sec=36

Implementați în fișierul timelib.c funcția:

TDate convertUnixTimestampToDateWithoutLeapYears(unsigned int timestamp)

Funcția trebuie să returneze ziua, luna și anul corespunzătoare timestamp-ului primit, sub forma unei structuri TDate:

typedef struct {
    unsigned char day;
    unsigned char month;
    unsigned int year;
} TDate

timestamp=0 => day=1; month=1; year=1970
timestamp=3659 => day=1; month=1; year=1970
timestamp=1703201916 => day=3; month=1; year=2024

Implementați în fișierul timelib.c funcția:

TDate convertUnixTimestampToDate(unsigned int timestamp)

Funcția trebuie să returneze ziua, luna și anul corespunzătoare timestamp-ului primit, sub forma unei structuri TDate ca la taskul anterior, însă luând în considerare anii bisecți. Un an bisect este un an cu 366 de zile (luna februarie are 29 de zile în loc de 28). Anii bisecți sunt toți anii divizibili cu 4 (e.g. 2004, 2008, 2012) cu excepția anilor care sunt multipli de 100 dar nu și multipli de 400 (exemplu: anii 2000 și 2400 sunt bisecți, dar anii 2100, 2200, 2300 nu sunt).

timestamp=0 => day=1; month=1; year=1970
timestamp=3659 => day=1; month=1; year=1970
timestamp=1703201916 => day=21; month=12; year=2023

Implementați în fișierul timelib.c funcția:

TDateTimeTZ convertUnixTimestampToDateTimeTZ(unsigned int timestamp, TTimezone *timezones, int timezone_index)

Funcția primește un Unix Timestamp, un vector de timezone-uri, și un index care definește timezone-ul din vector ce trebuie folosit. Un timezone (fus orar) este reprezentat de o structură TTimezone, cu următoarele componente:

• name: numele timezone-ului (e.g.: “UTC”, “GMT”, “EET”, “EST”)
• utc_hour_difference: diferența în număr de ore față de timezone-ul UTC (în care se consideră că este orice Unix Timestamp).

typedef struct {
    char name[5];
    signed char utc_hour_difference;
} TTimezone

Funcția trebuie să returneze o structură TDateTimeTZ, cu următoarele componente:

• date: data corespunzătoare timestamp-ului primit
• time: ora, minutul, secunda corespunzătoare timestamp-ului primit
• tz: pointer la timezone-ul corespunzător din vectorul de timezone-uri

typedef struct {
    TDate date;
    TTime time;
    TTimezone *tz;
} TDateTimeTZ

Pentru această funcție, la conversia din Unix Timestamp în formatul Date+Time, trebuie luată în considerare diferența de timp impusă de timezone. Spre exemplu, timestamp-ul 1703201916 corespunde datei 21 decembrie 2023, ora 23:38:36 dacă acesta este considerat în timestamp-ul UTC (echivalent cu GMT), pentru care utc_hour_difference este 0. Însă același timestamp, într-un timezone în care utc_hour_difference este 2 (spre exemplu, EET) va corespunde datei 22 decembrie 2023, ora 01:38:36 (2 ore mai târziu). Același timestamp, într-un timezone în care utc_hour_difference este -5, va corespunde datei 21 decembrie 2023, ora 18:38:36.

timestamp=1703201916, timezone_index=0 => 21-12-2023 23:38:36
timestamp=1703201916, timezone_index=1 => 22-12-2023 01:38:36
timestamp=1703201916, timezone_index=2 => 21-12-2023 15:38:36

Implementați în fișierul timelib.c funcția:

unsigned int convertDateTimeTZToUnixTimestamp(TDateTimeTZ)

Funcția primește un TDateTimeTZ așa cum a fost definit mai sus și execută operația inversă, calculând Unix Timestamp-ul corespunzător.

21-12-2023 23:38:36 (UTC) => 1703201916
22-12-2023 01:38:36 (EET) => 1703201916
21-12-2023 15:38:36 (PST) => 1703201916

Implementați în fișierul timelib.c funcția:

void printDateTimeTZ(TDateTimeTZ datetimetz)

Funcția afișează la stdout datetime-ul primit, în următorul format: [data] [luna (cuvânt)] [anul], [ora]:[minutul]:[secunda] [timezone name] (UTC[+/-][timezone utc hour diff])

1 ianuarie 1970, 05:00:00 UTC (UTC+0)
22 decembrie 2023, 01:38:36 EET (UTC+2)
21 decembrie 2023, 15:38:36 PST (UTC-8)

Printr-o rețea de calculatoare se trimite un vector de obiecte de tip “dată” (zi, lună, an). Din motive de economisire a spațiului, aceste date sunt memorate pe biții unui unsigned int (presupunem unsigned int de 32 de biți), în următorul format:

Astfel, în cadrul unui unsigned int:

• cei mai nesemnificativi 5 biți memorează ziua, sub forma unui număr între 1 (00001) și 31 (11111)
• următorii 4 biți memorează luna, sub forma unui număr între 1 (0001) și 12 (1100)
• următorii 6 biți memorează anul ca diferență față de 1970, sub forma unui număr între 0 (000000) ce reprezintă anul 1970, și 63 (111111) ce reprezintă anul 2033

Scrieți un program (în fișierul bitpacking.c) care citește:

• numărul taskului (pentru acest task va fi 7)
• un număr natural N
• N numere de tip unsigned int ce reprezintă fiecare câte o dată memorată pe biți așa cum este definit mai sus.

Programul trebuie să afișeze la stdout datele citite, câte una pe linie, sortate în ordine cronologică, în formatul [zi] [lună] [an] (exemplu: 21 decembrie 2023).

Modificați programul din fișierul bitpacking.c pentru a rezolva acest task atunci când se citește 8 pentru numărul taskului.

O problemă majoră a packing-ului pe biți așa cum a fost definit la taskul 7 este că nu e foarte eficient. Deși sunt necesari doar 15 biți (6+4+5) pentru memorarea unei date, sunt folosiți cei 32 de biți ai unui unsigned int. Pentru a rezolva această problemă, vom împacheta datele la un loc folosind aceleași valori unsigned int. Astfel:

• prima dată se va regăsi în cei 15 cei mai nesemnificativi biți (0-14) din primul unsigned int citit
• a doua dată se va regăsi în următorii 15 biți ai primului unsigned int (ziua în biții 15-19, luna în biții 20-23, anul în biții 24-29)
• a treia dată se va regăsi în ultimii 2 biți (cei mai semnificativi) ai primului unsigned int și primii 13 biți ai celui de-al doilea unsigned int (ziua în biții 30-31 ai primului int și biții 0-3 ai următorului int; luna în biții 4-7, iar anul în biții 8-13 ai celui de-al doilea int)
• și asa mai departe.

Pentru un plus de realism, dorim să simulăm și cazul în care pe rețea există perturbații care alterează datele transmise. Pentru asta, vom avea câte un bit de control (separat de împachetarea descrisă mai sus) pentru fiecare unsigned int citit. Acest bit de control va fi definit ca B1%2, unde B1 reprezintă numărul de biți de 1 din unsigned int-ul respectiv. Spre exemplu:

• pentru unsigned int-ul 00000000 00000000 00000000 00000000, bitul de control va fi 0 (sunt 0x biți egali cu 1 în acest int)
• pentru unsigned int-ul 01010101 01010101 01010101 01010101, bitul de control va fi 0 (sunt 16x biți egali cu 1 în acest int, iar 16 este număr par - 16%2 == 0)
• pentru unsigned int-ul 01010101 01010101 01010101 01010111, bitul de control va fi 1 (sunt 17x biți egali cu 1 în acest int, iar 17 este număr impar - 17%2 == 1)

Biții de control vor fi și ei împachetați într-un șir de unsigned int-uri de control. Astfel:

• cel mai nesemnificativ bit din primul unsigned int de control reprezintă bitul de control pentru primul unsigned int citit
• următorul bit din primul unsigned int de control reprezintă bitul de control pentru al doilea int citit
• etc.

Biții de control vor fi folosiți astfel:

1. pentru fiecare unsigned int de date citit, se numără biții egali cu 1 din acesta (B1) și se calculează B1%2
2. se compară această valoare calculată cu bitul de control citit de la stdin
3. dacă cele două valori coincid, se consideră că acest unsigned int de date a fost recepționat corect de pe rețea
4. dacă cele două valori nu coincid, se consideră că acest unsigned int a fost corrupted, prin urmare toate datele ai căror biți fac parte din acest unsigned int vor fi ignorate și nu vor fi afișate în outputul programului.

Modificați programul de la task 7 (în fișierul bitpacking.c) astfel încât, atunci când numărul taskului citit este 8, să ruleze cu următoarele modificări:

• citește un număr natural N, ca mai devreme, ce reprezintă numărul de date (atenție - numărul de date, nu de int-uri) care trebuie citite
• citește un șir de unsigned int-uri ce conțin aceste date împachetate după descrierea de mai sus, până se citesc toate cele N date
• citește un șir de unsigned int-uri de control până se află valoarea bitului de control pentru toate unsigned int-urile de date citite

Programul trebuie să afișeze la stdout datele citite (dar numai cele ai căror biți sunt în totalitate numai în unsigned int-uri care nu sunt corupte), câte una pe linie, sortate în ordine cronologică, în același format ca la taskul 7.

Ne propunem să creăm un sistem de management de evenimente care găsește automat un interval de timp în care persoanele ce trebuie să participe la eveniment sunt libere.

Scrieți un program (în fișierul planner.c) care:

• citește un număr T ce reprezintă numărul de timezone-uri din program
• citește fiecare timezone, câte unul pe linie:
  • numele timezone-ului (un string de maxim 4 caractere), și diferența în ore față de UTC
• citește un număr P ce reprezintă numărul de persoane
• pentru fiecare persoană, citește următoarele:
  • numele persoanei (un cuvânt de maxim 10 caractere)
  • numele timezone-ului în care această persoană locuiește
  • un număr K ce reprezintă numărul de intervale în care această persoană este liberă
  • citește fiecare interval, dat de următoarele informații:
    • anul, luna, ziua, ora când intervalul liber începe (datele sunt considerate în timezone-ul persoanei careia îi aparțin)
    • durata intervalului liber în număr de ore
• citește parametrii evenimentului:
  • un număr întreg F (F mai mic sau egal cu P) ce reprezintă numărul minim de persoane care trebuie să participe la eveniment
  • durata evenimentului în număr de ore

Programul trebuie să găsească primul interval temporal în care evenimentul se poate organiza astfel încât minim F persoane să fie disponibile pe întreaga durată a evenimentului. Dacă nu există niciun interval în care să se poată organiza evenimentul, programul trebuie să afișeze “imposibil”. Dacă se găsește un interval în care evenimentul se poate ține, atunci programul trebuie să afișeze P linii (câte una pentru fiecare dintre cele P persoane, sortate alfabetic după nume), cu următorul conținut:

• dacă persoana respectivă poate ajunge la eveniment, se afișează [nume]: [data] (data fiind reprezentată sub forma an, lună, zi, oră, minut, secundă, timezone - în același format ca la taskul 6) evenimentului, în timezone-ul acestei persoane
• dacă persoana respectivă nu va fi disponibilă pentru eveniment, se afișează “invalid”

1
UTC 0

3

Alin UTC 1
2023 12 20 12 5

Vlad UTC 3
2023 12 20 12 1
2023 12 20 14 2
2023 12 20 16 1

Traian UTC 1
2023 12 20 12 1

2 3

Alin: 20 decembrie 2023, 14:00:00 UTC (UTC+0)
Traian: invalid
Vlad: 20 decembrie 2023, 14:00:00 UTC (UTC+0)

3
UTC 0
EET 2
PST -8

3

Alin UTC 1
2023 12 20 12 5

Vlad EET 3
2023 12 20 14 1
2023 12 20 16 2
2023 12 20 18 1

Traian PST 1
2023 12 20 4 1

2 3

Pentru acest task, trebuie să aveți punctajul maxim pe taskul 9 și să nu aveți memory leaks la verificarea folosind utilitarul valgrind pe acesta.

Utilitarul se va rula folosind urmatoarea comanda:

 valgrind --tool=memcheck --leak-check=full --error-exitcode=1 ./planner 

La fel ca la temele precedente, există o depunctare de până la -20p pentru coding style. Checkerul verifică coding style-ul în mod automat.

Checker: t2_checker.zip

Tema va fi trimisă folosind Moodle, cursul Programarea Calculatoarelor (CB & CD), activitatea “Tema 2”.

Toate temele sunt testate în mod automat pe Moodle.

Arhiva temei se va încărca folosind formularul de submisie (butonul Add submission.

Rezultatele vor fi disponibile în secțiunea Feedback - nota apare la linia Grade, iar outputul checkerului și erorile apar la sectiunea Feedback comments. Dacă apare un buton albastru în formă de plus, trebuie să dați click pe el pentru a afișa întregul output al checkerului.
Citiți cu atenție informațiile afișate în Feedback pentru a vă asigura că tema a fost rulată cu succes; o eroare comună este dată de faptul că conținutul arhivei nu respectă structura dorită (ex. fișierele sunt într-un alt director).

Punctajul final al temei este afișat la linia Grade și la finalul outputului din checker.

Conținutul arhivei trebuie să fie următorul:

1. Fișierele timelib.c, timelib.h
2. Fișierul bitpacking.c
3. Fișierul planner.c
4. Fișierul Makefile
5. Un fișier README în care descrieți rezolvarea temei.

Lista nu este exhaustivă.

• O temă care nu compilează și nu a rulat pe vmchecker nu va fi luată în considerare
• O temă care nu rezolvă cerința și trece testele prin alte mijloace nu va fi luată în considerare
• NU acceptăm teme copiate. În cazul unei teme copiate se scade punctajul aferent temei din punctajul total.
• [-20.0]: Nerezolvarea tuturor erorilor și warningurilor de coding style