# Zadanie 1

binary semaphore mutex;
semaphore wolne_drukarki = K;
int ile_wolnych = K;
binary semaphore drukarki[K];

int ile_osob[K];
int ktora_drukarka[N];
int ile_czeka[N];
semaphore firmy[N];

process Pracownik{
	int firma;
  
  while(true){
    P(mutex);
    if(ktora_drukarka[firma] == -1 || ile_wolnych == 0){
      ile_czeka[firma] += 1;
			if(ile_czeka[firma] == 1){
        if(ile_wolnych == 0) V(mutex);
      	P(wolne_drukarki);
        for(int i = 0; i < K; i++){
        	if(ile_osob[i] == 0){
            ile_wolnych--;
            ktora_drukarka[firma] = i;
            break;
          }
        }
      }else{
        V(mutex);
      	P(firmy[firma]);
      }
      ile_czeka[firma]--;
    }
    ile_osob[ktora_drukarka[firma]]++;
    if(ile_czeka[firma] > 0){
    	V(firmy[firma]);
    }else{
      V(mutex);
    }
    
    P(drukarka[ktora_drukarka[firma]]);
    drukuj(ktora_drukarka[firma]);
    ile_osob[ktora_drukarka[firma]] -= 1;  
    V(drukarka[ktora_drukarka[firma]]);
    
    P(mutex);
    if(ile_osob[ktora_drukarka[firma]] == 0){
    	ile_wolnych++;
      ktora_drukarka[firma] = -1;
      V(wolne_drukarki);
    }else{
      V(mutex);
    }
  }
};

# Zadanie 2

binary semaphore mutex = 1;
semaphore liderzy = 1;
semaphore czekaj_na_przeciwnika = 0;
sempahore druzyny[N] = {0, ..., 0};
int ile_gotowych_druzyn = 0;
int ile_czeka[N] = {0, ..., 0};
int ile_gra[N] = {0, ..., 0};
int z_kim_gra[N] = {-1, ..., -1};
int kim_jestem = -1;

process Zawodnik{
  int druzyna;
  
  while(true){
  	P(mutex);
    ile_czeka[druzyna]++;
    if(ile_czeka[druzyna] == K){
      ile_gotowych_druzyn++;
      V(mutex);
    	P(liderzy);
      
      if(kim_jestem == -1){
        kim_jestem = druzyna;
        V(liderzy);
      	P(czekaj_na_przeciwnika);
      }else{
        z_kim_gra[druzyna] = kim_jestem;
        z_kim_gra[kim_jestem] = druzyna;
        kim_jestem = -1;
      	V(czekaj_na_przeciwnika);
      }
      ile_gotowych_druzyn--;
    }else{
      V(mutex);
    	P(druzyny[druzyna]);
    }
    
    ile_czeka[druzyna]--;
    ile_gra[druzyna]++;
    
    if(ile_czeka[druzyna] > 0){
    	V(druzyny[druzyna]);
    }
    
    if(ile_czeka[druzyna] == 0 && ile_czeka[z_kim_gra[druzyna]] == 0)
        V(mutex);
    
    mecz(z_kim_gra[druzyna]);
    
    P(mutex);
    ile_gra[druzyna]--;
    if(ile_gra[druzyna] == 0 && ile_gra[z_kim_gra[druzyna]] == 0){
      V(liderzy);
      if(ile_gotowych_druzyn == 0) V(mutex);
    }else{
      V(mutex);
    }
  };
};

# Zadanie 4

binary semaphore mutex = 1;
semaphore reszta[2] = {0, 0};
semaphore grupa[2] = {0, 0};
semaphore lider = 0;
int suma_wag[2] = {0, 0};
int ile_czeka[2] = {0, 0};
int ile_reszty[2] = {0, 0};
bool gotowi[2] = {false, false};

process P(int typ, int waga){
	while(true){
  	wlasneSprawy();
    P(mutex);
    if(suma_wag[typ] + waga > 3*K){
      ile_reszty[typ]++;
      V(mutex);
      P(reszta[typ]);
      ile_reszty[typ]--;
    }
    
  	if(suma_wag[typ] + waga < 2 * k){
    	ile_czeka[typ]++;
      suma_wag[typ] += waga;
      if(ile_reszty[typ] > 0) V(reszta[typ]);
      else V(mutex);
      P(grupa[typ]);
    }else{
    	gotowi[typ] = true;
      if(gotowi[1 - typ]){
      	V(lider);
      }else{
        V(mutex);
      	P(lider);
      }
      suma_wag[typ] = 0;
      gotowi[typ] = false;
    }

    ile_czeka[typ]--;
    if(ile_czeka[typ] > 0){
    	V(grupa[typ]);
    }else if(ile_czeka[1-typ] ==0){
    	V(mutex);
    }
    
    zadanie();
  }
}

# Zadanie 5

binary semaphore mutex = 1;
semaphore klient_czekaj = 0;
int ile_klientow = 0;
semaphore pracownik_czekaj = 0;
semaphore pracownik_czekaj_na_id = 0;
binary semaphore gotowy = 0;

int ile_pracownikow = 0;
int ile_czeka_na_id = 0;
int suma_doswiadczen = 0;
int doswiadczenie_grupy = 0;
int id_grupy = -1;
int id_klienta = -1;
bool klient_wyszedl = false;

process Klient(){
  int id;
  
	while(true){
    P(mutex);
  	if(suma_doswiadczen < M){
      ile_klientow++;
      V(mutex);
    	P(klient_czekaj);
    }else{
    	V(pracownik_czekaj);
    }
    ile_klientow--;
    
    P(gotowy);
    
    id_klienta = id;
    
    V(pracownik_czekaj_na_id);
    
    obsluga(id_grupy);
    
    klient_wyszedl = true;
    if(ilu_pracownikow == 0)
      id_klienta = -1;
    	klient_wyszedl = false;
      V(mutex);
  }
}

process Pracownik(){
  int id;
  int doswiadczenie;
	
  while(true){
  	P(mutex);
    suma_doswiadczen += doswiadczenie;
    if(suma_doswiadczen < M || ile_klientow == 0){
      V(mutex);
    	P(pracownik_czekaj);
    }else{
    	V(klient_czekaj);
    }
    
    suma_doswiadczen -= doswiadczenie;
    doswiadczenie_grupy += doswiadczenie;
    ile_czeka_na_id++;
    ile_pracownikow++;
    
    if(ile_pracownikow == 1){
    	init(id, id_grupy);
    }else{
      dodaj(id_grupy, id);
    }
    
    if(doswiadczenie_grupy < M){
    	V(pracownik_czekaj);
    }else{
    	V(gotowy);
    }
    
    P(pracownik_czekaj_na_id);
    ile_czeka_na_id--;
    if(ile_czeka_na_id > 0) 
      V(pracownik_czekaj_na_id);
    
    praca(id_klienta);
    
    ile_pracownikow--;
    if(ile_pracownikow == 0 && czy_klient_wyszedl)
      id_klienta = -1;
      klient_wyszedl = false;
      V(mutex);
  }
}

# Zadanie 6

process Goral(){
  int numer_gorala;
  while (true) {
    czekam_na_turystow(numer_gorala);
    czekam_na_wysiadajacych(numer_gorala);
  }
}

process Turysta(){
  while (true) {
    int ktorym_jade;
	  czekam_na_woz(ktorym_jade);
    wysiadam(ktorym_jade);
  }
}

Monitor MOKO(){
  condition turysta;
  condition woz[k];
  int ile_turystow = 0;
  int ile_w_wozie[K] = {0, ..., 0};
  int moj_woz = -1;

  condition goral;

	void czekam_na_woz(int &ktorym_jade){
  	ile_turystow++;
    if(ile_turystow < MIN || empty(goral)){
    	wait(turysta);
    }else{
    	signal(goral);
    }

    ktorym_jade = moj_woz;
    ile_turystow--;
    ile_w_wozie[ktorym_jade]++;
    
    if(ile_turystow > 0 && ile_w_wozie[ktorym_jade] < MAX) 
      	signal(turysta);
  }

	void wysiadam(int &ktorym_jade){
    ile_w_wozie[ktorym_jade]--;
    if (ile_w_wozie[ktorym_jade] == 0)
    	signal(woz[ktorym_jade])
  }

	void czekam_na_turystow(int n){
  	if(ile_turystow < MIN){
    	wait(goral);
    }
    
    moj_woz = n;
    
    signal(turysta);
  }

	void czekam_na_wysiadajacych(int n){
  	if(ile_w_wozie[n] > 0) wait(woz[n]);
  }
}

# Zadanie 7

process Turysta(){
	int id;
  while(true){
    wlasne_sprawy();
    int lewy = 0, prawy = 0;
    int przewodnik = 0;
    chce_isc(przewodnik, lewy, prawy, id);
    wycieczka(przewodnik, lewy, prawy);
  }
}

process Przewodnik(){
	int id;
  while(true){
    wlasne_sprawy();
  	int ile_turystow;
    chce_turystow(ile_turystow, id);
    prowadze_wycieczke(ile_turystow);
  }
}

monitor Wycieczka{
  int ile_turystow = 0;
  condition turysta;
  condition przewodnik;
  
  int przewodnik_grupy = 0;
  int ile_w_grupie = 0;
  int lewy = 0;
  int prawy = 0;
  
	void chce_isc(int *_przewodnik, int *_lewy, int *_prawy, int _id){
    ile_turystow++;
  	if(ile_turystow < min || empty(przewodnik)){
    	wait(turysta);
    }else{
    	signal(przewodnik);
    }
    
    _przewodnik = przewodnik_grupy;
    _lewy = lewy;
    lewy = _id;
    ile_turystow--;
    ile_w_grupie++;
    
    if(ile_w_grupie < max && ile_turystow > 0){
    	signal(turysta);
    }
    
    _prawy = prawy;
    prawy = id;
    
    if(_lewy == 0){
    	lewy = 0;
      prawy = 0;
      ile_w_grupie = 0;
      przewodnik_grupy = 0;
    }
  }
  
  void chce_turystow(int *_ile_turystow, int _id){
    if(ile_turystow < min){
    	wait(przewodnik);
    }
    
    przewodnik_grupy = _id;
    _ile_turystow = ile_turystow > max ? max : ile_turystow;
  }
}