Rozwiązania zadań domowych

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z01_ziemniaki/Zakupy1.java

+package rozwiazania_zadan.r1.z01_ziemniaki;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy1 {
+
+	public static void main(String[] args) {
+		String cenaTekstowo = JOptionPane.showInputDialog("Ile kosztuje kilo ziemniaków?");
+		double cenaZ = Double.parseDouble(cenaTekstowo);
+		double kosztZ = cenaZ * 5;
+		JOptionPane.showMessageDialog(null, "Za 5 kg ziemniaków zapłacisz " + kosztZ);
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z01_ziemniaki/Zakupy2.java

+package rozwiazania_zadan.r1.z01_ziemniaki;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy2 {
+
+	public static void main(String[] args) {
+		double cenaZ = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje 1 kg ziemniaków?"));
+		double iloscZ = Double.parseDouble(JOptionPane.showInputDialog("Ile kg ziemniaków kupujesz?"));
+		double kosztZ = cenaZ * iloscZ;
+		JOptionPane.showMessageDialog(null, "Za " + iloscZ +" kg ziemniaków zapłacisz " + kosztZ + " zł");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z01_ziemniaki/Zakupy3.java

+package rozwiazania_zadan.r1.z01_ziemniaki;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy3 {
+
+	public static void main(String[] args) {
+		double cenaZ = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje 1 kg ziemniaków?"));
+		double iloscZ = Double.parseDouble(JOptionPane.showInputDialog("Ile kg ziemniaków kupujesz?"));
+		double kosztZ = cenaZ * iloscZ;
+
+		double cenaB = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje 1 kg bananów?"));
+		double iloscB = Double.parseDouble(JOptionPane.showInputDialog("Ile kg bananów kupujesz?"));
+		double kosztB = cenaB * iloscB;
+		
+		double kosztSuma = kosztZ + kosztB;
+
+		JOptionPane.showMessageDialog(null,
+				String.format("Za %.3f kg ziemniaków płacisz %.2f zł\n"
+						+ "Za %.3f kg bananów płacisz %.2f zł\n"
+						+ "Łącznie płacisz %.2f zł",
+						iloscZ, kosztZ, iloscB, kosztB, kosztSuma
+					));
+		
+		if(kosztZ > kosztB) {
+			JOptionPane.showMessageDialog(null, "Więcej kosztują ziemniaki.");
+		} else if(kosztZ < kosztB) {
+			JOptionPane.showMessageDialog(null, "Więcej kosztują banany.");
+		} else {
+			JOptionPane.showMessageDialog(null, "Za oba produkty płacisz tyle samo.");
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z02_trojkat/Trojkat1.java

+package rozwiazania_zadan.r1.z02_trojkat;
+
+import java.util.Locale;
+import java.util.Scanner;
+/*
+  Napisz program, który prosi użytkownika (w konsoli lub okienku) o podanie trzech liczb,
+  po czym informuje go (wyświetlając komunikat w ten sposób, w jaki nastąpiło wczytanie liczb),
+  czy mogą one być długościami boków trójkąta.
+  Przykładem liczb, które nie mogą być długościami boków trójkąta, są: 1, 2, 5
+  - program ma wyświetlać prawidłową odpowiedź dla dowolnej kolejności wpisywania liczb.
+  
+  Jeśli długości boków tworzą trójkąt, to oblicz pole powierzchni (wzór Herona).
+ */
+public class Trojkat1 {
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		System.out.println("Podaj trzy liczby, długości boków trójkąta:");
+		double a = sc.nextDouble();
+		double b = sc.nextDouble();
+		double c = sc.nextDouble();
+		
+		if(a + b > c && b + c > a && c + a > b) {
+			System.out.println("OK, te liczby mogą być długościami boków trójkąta");
+			double p = (a + b + c) / 2.0;
+			double pole = Math.sqrt((p - a) * (p - b) * (p - c) * p);
+			System.out.println("Pole powierzchni wynosi: " + pole);
+		} else {
+			System.out.println("Te liczby nie mogą być długościami boków trójkąta");
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z02_trojkat/Trojkat2_WersjaZFunkcjami.java

+package rozwiazania_zadan.r1.z02_trojkat;
+
+import java.util.Locale;
+import java.util.Scanner;
+/*
+ W programie z zadania 1. wydziel sprawdzanie, czy liczby mogą być długościami boków trójkąta,
+ do osobnej funkcji. Jakiego typu wartość ma zwracać ta funkcja?
+ Ile ma przyjmować argumentów i jakich mają one być typów?
+ 
+ Przy okazji wydzielam także obliczanie pola.
+ */
+public class Trojkat2_WersjaZFunkcjami {
+	
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		System.out.println("Podaj trzy liczby, długości boków trójkąta:");
+		double a = sc.nextDouble();
+		double b = sc.nextDouble();
+		double c = sc.nextDouble();
+		
+		if(czyToJestTrojkat(a, b, c)) {
+			System.out.println("OK, te liczby mogą być długościami boków trójkąta");
+			double pole = poleTrojkata(a, b, c);
+			System.out.println("Pole powierzchni wynosi: " + pole);
+		} else {
+			System.out.println("Te liczby nie mogą być długościami boków trójkąta");
+		}
+	}
+
+	static boolean czyToJestTrojkat(double a, double b, double c) {
+		return a + b > c && b + c > a && c + a > b;
+	}
+	
+	static double poleTrojkata(double a, double b, double c) {
+		double p = (a + b + c) / 2.0;
+		double pole = Math.sqrt((p - a) * (p - b) * (p - c) * p);
+		return pole;
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/a_wersje_robocze/Szewc0.java

+package rozwiazania_zadan.r1.z03_szewc.a_wersje_robocze;
+
+import javax.swing.JOptionPane;
+
+public class Szewc0 {
+
+	public static void main(String[] args) {
+		String numerTekstowo = JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy");
+		int poczatek = Integer.parseInt(numerTekstowo);
+		
+		String czasTekstowo = JOptionPane.showInputDialog("Ile dni potrwa naprawa?");
+		int czasNaprawy = Integer.parseInt(czasTekstowo);
+		
+		int koniec = poczatek + czasNaprawy;
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/a_wersje_robocze/Szewc1.java

+package rozwiazania_zadan.r1.z03_szewc.a_wersje_robocze;
+
+import javax.swing.JOptionPane;
+
+public class Szewc1 {
+
+	public static void main(String[] args) {
+		String numerTekstowo = JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy");
+		int poczatek = Integer.parseInt(numerTekstowo);
+		
+		String czasTekstowo = JOptionPane.showInputDialog("Ile dni potrwa naprawa?");
+		int czasNaprawy = Integer.parseInt(czasTekstowo);
+		
+		int koniec = poczatek + czasNaprawy;
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+		
+		if(koniec == 1) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to poniedziałek");
+		} else if(koniec == 2) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to wtorek");
+		} else if(koniec == 3) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to środa");
+		} else if(koniec == 4) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to czwartek");
+		} else if(koniec == 5) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to piątek");
+		} else if(koniec == 6) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to sobota");
+		} else if(koniec == 7) {
+			JOptionPane.showMessageDialog(null, "Ten dzień to niedziela");
+		} else {
+			JOptionPane.showMessageDialog(null, "Dzień poza zakresem");
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/a_wersje_robocze/Szewc2.java

+package rozwiazania_zadan.r1.z03_szewc.a_wersje_robocze;
+
+import javax.swing.JOptionPane;
+
+public class Szewc2 {
+
+	public static void main(String[] args) {
+		int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy"));
+		int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+		
+		int koniec = poczatek + czasNaprawy;
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+		
+		switch(koniec) {
+		case 1:
+			JOptionPane.showMessageDialog(null, "Ten dzień to poniedziałek");
+			break;
+		case 2:
+			JOptionPane.showMessageDialog(null, "Ten dzień to wtorek");
+			break;
+		case 3:
+			JOptionPane.showMessageDialog(null, "Ten dzień to środa");
+			break;
+		case 4:
+			JOptionPane.showMessageDialog(null, "Ten dzień to czwartek");
+			break;
+		case 5:
+			JOptionPane.showMessageDialog(null, "Ten dzień to piątek");
+			break;
+		case 6:
+			JOptionPane.showMessageDialog(null, "Ten dzień to sobota");
+			break;
+		case 7:
+			JOptionPane.showMessageDialog(null, "Ten dzień to niedziela");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Dzień poza zakresem");
+			break;
+		}
+		
+		
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/a_wersje_robocze/Szewc3.java

+package rozwiazania_zadan.r1.z03_szewc.a_wersje_robocze;
+
+import javax.swing.JOptionPane;
+
+public class Szewc3 {
+
+	public static void main(String[] args) {
+		int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy"));
+		int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+		
+		int koniec = poczatek + czasNaprawy;
+		
+		while(koniec > 7) {
+			koniec -= 7;
+		}
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+		
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/a_wersje_robocze/Szewc4.java

+package rozwiazania_zadan.r1.z03_szewc.a_wersje_robocze;
+
+import javax.swing.JOptionPane;
+
+public class Szewc4 {
+
+	public static void main(String[] args) {
+		int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy"));
+		int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+		
+		int koniec = (poczatek + czasNaprawy) % 7;
+
+		// technika aby wyniki były z zakresu od 1 do 7
+		// int koniec = (poczatek + czasNaprawy - 1) % 7 + 1;
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+		
+		switch(koniec) {
+		case 1:
+			JOptionPane.showMessageDialog(null, "Ten dzień to poniedziałek");
+			break;
+		case 2:
+			JOptionPane.showMessageDialog(null, "Ten dzień to wtorek");
+			break;
+		case 3:
+			JOptionPane.showMessageDialog(null, "Ten dzień to środa");
+			break;
+		case 4:
+			JOptionPane.showMessageDialog(null, "Ten dzień to czwartek");
+			break;
+		case 5:
+			JOptionPane.showMessageDialog(null, "Ten dzień to piątek");
+			break;
+		case 6:
+			JOptionPane.showMessageDialog(null, "Ten dzień to sobota");
+			break;
+		case 0:
+			JOptionPane.showMessageDialog(null, "Ten dzień to niedziela");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Dzień poza zakresem");
+			break;
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/b_wersje_poprawne/Szewc5_While.java

+package rozwiazania_zadan.r1.z03_szewc.b_wersje_poprawne;
+
+import javax.swing.JOptionPane;
+
+public class Szewc5_While {
+
+	static String nazwaDniaTygodnia(int numer) {
+		switch(numer) {
+		case 1: return "poniedziałek";
+		case 2: return "wtorek";
+		case 3: return "środa";
+		case 4: return "czwartek";
+		case 5: return "piątek";
+		case 6: return "sobota";
+		case 7: return "niedziela";
+		default: throw new IllegalArgumentException("Nieprawidłowy numer dnia tygodnia " + numer);
+		}
+	}
+	
+	public static void main(String[] args) {
+		int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia\nkiedy oddajesz buty do naprawy:"));
+		int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni będzie trwać naprawa?"));
+		
+		// ewentualnie można sprawdzać poprawność danych wejściowych
+		
+		int koniec = poczatek + czasNaprawy;
+		while(koniec > 7) {
+			koniec -= 7;
+		}
+		
+		String nazwa = nazwaDniaTygodnia(koniec);
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień " + koniec + ", czyli " + nazwa +".");
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/b_wersje_poprawne/Szewc6_Modulo.java

+package rozwiazania_zadan.r1.z03_szewc.b_wersje_poprawne;
+
+import javax.swing.JOptionPane;
+
+public class Szewc6_Modulo {
+
+	public static void main(String[] args) {
+		int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia kiedy oddajesz buty do naprawy"));
+		int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+		
+		int koniec = (poczatek + czasNaprawy) % 7;
+
+		// technika aby wyniki były z zakresu od 1 do 7
+		// int koniec = (poczatek + czasNaprawy - 1) % 7 + 1;
+		
+		JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dniu nr " + koniec);
+		String nazwa = nazwaDniaTygodnia(koniec);
+		JOptionPane.showMessageDialog(null, "Ten dzień to " + nazwa);
+	}
+
+	public static String nazwaDniaTygodnia(int koniec) {
+		switch(koniec) {
+		case 0: case 7: return "niedziela";
+		case 1: return "poniedziałek";
+		case 2: return "wtorek";
+		case 3: return "środa";
+		case 4: return "czwartek";
+		case 5: return "piątek";
+		case 6: return "sobota";
+		default: return "Dzień poza zakresem";
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z03_szewc/b_wersje_poprawne/Szewc7_Gotowe.java

+package rozwiazania_zadan.r1.z03_szewc.b_wersje_poprawne;
+
+import java.awt.HeadlessException;
+
+import javax.swing.JOptionPane;
+
+public class Szewc7_Gotowe {
+
+	static String nazwaDniaTygodnia(int numer) {
+		switch(numer) {
+		case 1: return "poniedziałek";
+		case 2: return "wtorek";
+		case 3: return "środa";
+		case 4: return "czwartek";
+		case 5: return "piątek";
+		case 6: return "sobota";
+		case 7: return "niedziela";
+		default: throw new IllegalArgumentException("Nieprawidłowy numer dnia tygodnia " + numer);
+		}
+	}
+	
+	public static void main(String[] args) {
+		try {
+			int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia\nkiedy oddajesz buty do naprawy:"));
+			int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni będzie trwać naprawa?"));
+			
+			int koniec = (poczatek + czasNaprawy - 1) % 7 + 1;
+			
+			String nazwa = nazwaDniaTygodnia(koniec);
+			JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień " + koniec + ", czyli " + nazwa +".");
+		} catch (HeadlessException e) {
+			System.err.println("Brak interfejsu graficznego, program się nie uruchomi...");
+			e.printStackTrace();
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z04_remont/FirmaRemontowa1.java

+package rozwiazania_zadan.r1.z04_remont;
+
+import javax.swing.JOptionPane;
+
+public class FirmaRemontowa1 {
+
+	public static void main(String[] args) {
+		double dlug = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość pokoju"));
+		double szer = Double.parseDouble(JOptionPane.showInputDialog("Podaj szerokość pokoju"));
+		double wys = Double.parseDouble(JOptionPane.showInputDialog("Podaj wysokość pokoju"));
+
+		double obwod = 2 * dlug + 2 * szer;
+		double pow_podlogi = dlug * szer;
+		double pow_scian = obwod * wys;
+		
+		double koszt = pow_scian * 30.0 + (pow_scian + pow_podlogi) * 15.0 + pow_podlogi * 20.0 + obwod * 10.0;
+		JOptionPane.showMessageDialog(null, "Sumaryczny koszt robót: " + koszt + " zł");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z04_remont/FirmaRemontowa2.java

+package rozwiazania_zadan.r1.z04_remont;
+
+import javax.swing.JOptionPane;
+
+public class FirmaRemontowa2 {
+
+	public static void main(String[] args) {
+		double szerokosc = Double.parseDouble(JOptionPane.showInputDialog("Podaj szerokość pomieszczenia"));
+		double dlugosc = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość pomieszczenia"));
+		double wysokosc = Double.parseDouble(JOptionPane.showInputDialog("Podaj wysokość", "2.50"));
+		
+		double powierchniaPodlogi = dlugosc * szerokosc;
+		double obwod = 2*dlugosc + 2*szerokosc;
+		double powierzchniaScian = obwod * wysokosc;
+		
+		double cena_gipsowanie = 30;
+		double cena_malowanie = 15;
+		double cena_panele = 20;
+		double cena_listwy = 10;
+		
+		double suma = 0;
+		if(JOptionPane.showConfirmDialog(null, "Czy chcesz wykonać gipsowanie?") == JOptionPane.YES_OPTION) {
+			double kosztGipsowania = cena_gipsowanie * powierzchniaScian;
+			suma += kosztGipsowania;
+		}
+
+		if(JOptionPane.showConfirmDialog(null, "Czy chcesz wykonać malowanie?") == JOptionPane.YES_OPTION) {
+			double kosztMalowania = cena_malowanie * (powierzchniaScian + powierchniaPodlogi);
+			suma += kosztMalowania;
+		}
+
+		if(JOptionPane.showConfirmDialog(null, "Czy chcesz położyć panele i listwy podłogowe?") == JOptionPane.YES_OPTION) {
+			double kosztPaneli = cena_panele * powierchniaPodlogi;
+			double kosztListew = cena_listwy * obwod;
+			suma += kosztPaneli + kosztListew;
+		}
+
+		JOptionPane.showMessageDialog(null,
+				String.format("Koszt sumaryczny wynosi %.2f", suma));
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z04_remont/FirmaRemontowa3.java

+package rozwiazania_zadan.r1.z04_remont;
+
+import java.util.Locale;
+
+import javax.swing.JOptionPane;
+
+public class FirmaRemontowa3 {
+
+	private static final double CENA_GIPS = 30.0;
+	private static final double CENA_MALOWANIE = 15.0;
+	private static final double CENA_PANELE = 20.0;
+	private static final double CENA_LISTWY = 10.0;
+
+	public static void main(String[] args) {
+		Locale.setDefault(Locale.US); // aby ułamki dziesiętne wszędzie były z kropką
+		
+		double dlug = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość pokoju"));
+		double szer = Double.parseDouble(JOptionPane.showInputDialog("Podaj szerokość pokoju"));
+		double wys = Double.parseDouble(JOptionPane.showInputDialog("Podaj wysokość pokoju", "2.50"));
+
+		double obwod = 2 * dlug + 2 * szer;
+		double pow_podlogi = dlug * szer;
+		double pow_scian = obwod * wys;
+		
+		
+		double koszt = 0.0;
+
+		double koszt_gips = pow_scian * CENA_GIPS;
+		if(zapytaj("Gipsowanie", koszt_gips)) {
+			koszt += koszt_gips;
+		}
+
+		double koszt_mal = (pow_scian + pow_podlogi) * CENA_MALOWANIE;
+		if(zapytaj("Malowanie", koszt_mal)) {
+			koszt += koszt_mal;
+		}
+
+		double koszt_panel = pow_podlogi * CENA_PANELE;
+		if(zapytaj("Założenie paneli", koszt_panel)) {
+			koszt += koszt_panel;
+		}
+
+		double koszt_listw = obwod * CENA_LISTWY;
+		if(zapytaj("Założenie listew", koszt_listw)) {
+			koszt += koszt_listw;
+		}
+		
+		JOptionPane.showMessageDialog(null, String.format("Sumaryczny koszt robót: %.2f zł", koszt));
+	}
+	
+	static boolean zapytaj(String robota, double cena) {
+		String txt = String.format("%s kosztowałoby %.2f zł\nCzy chcesz wykonać tę pracę?", robota, cena);
+		int wybor = JOptionPane.showConfirmDialog(null, txt, "Pytanie", JOptionPane.YES_NO_OPTION);
+		return wybor == JOptionPane.YES_OPTION;
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z05_choinka/Choinka1.java

+package rozwiazania_zadan.r1.z05_choinka;
+
+import java.util.Scanner;
+
+public class Choinka1 {
+
+	public static void main(String[] args) {
+		// Napisy powinny być jednakowej długości
+		final String PUSTE = " ";
+		final String ZNAK = "*";
+		
+		Scanner sc = new Scanner(System.in);
+		System.out.print("Podaj wysokość choinki: ");
+		int h = sc.nextInt();
+		for(int w = 0; w < h; w++) {
+			for(int k = 1; k <= h-w; k++) {
+				System.out.print(PUSTE);
+			}
+			for(int k = 1; k <= 2*w+1; k++) {
+				System.out.print(ZNAK);
+			}
+			// ostatni for opcjonalnie, aby linie były jednakowej długości przy zaznaczaniu itp.
+			// albo gdy PUSTE będzie czymś innym niż spacja
+			for(int k = 1; k <= h-w; k++) {
+				System.out.print(PUSTE);
+			}
+			System.out.println();
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z06_zgadywanka/MaloDuzo_v1.java

+package rozwiazania_zadan.r1.z06_zgadywanka;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class MaloDuzo_v1 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		Random r = new Random();
+		int szukana = r.nextInt(1000);
+		System.out.println("Wylosowałem liczbę z zakresu od 0 do 999. Spróbuj ją odgadnąć...");
+		
+		int ileProb = 0;
+		while(true) {
+			ileProb += 1;
+			System.out.println("Wprowadź liczbę: ");
+			int propozycja = sc.nextInt();
+			if(propozycja < szukana) {
+				System.out.println("Podana liczba jest zbyt mała.");
+			} else if(propozycja > szukana) {
+				System.out.println("Podana liczba jest zbyt duża.");
+			} else {
+				System.out.println();
+				System.out.println("Brawo! Tą liczbą jest " + szukana);
+				System.out.println("Udało ci się odgadnąć w " + ileProb + " próbie.");
+				break;
+			}
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z06_zgadywanka/MaloDuzo_v2.java

+package rozwiazania_zadan.r1.z06_zgadywanka;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class MaloDuzo_v2 {
+
+	public static void main(String[] args) {
+		final int LIMIT = 1000;
+		Scanner sc = new Scanner(System.in);
+		
+		Random r = new Random();
+		int szukana = r.nextInt(LIMIT);
+		
+		System.out.println("Wylosowałem liczbę z zakresu od 0 do " + (LIMIT-1) + ". Spróbuj ją odgadnąć...");
+		
+		int ileProb = 0;
+		int propozycja;
+		do {
+			ileProb += 1;
+			System.out.println("Wprowadź liczbę: ");
+			propozycja = sc.nextInt();
+			if(propozycja < szukana) {
+				System.out.println("Podana liczba jest zbyt mała.");
+			} else if(propozycja > szukana) {
+				System.out.println("Podana liczba jest zbyt duża.");
+			}
+		} while(propozycja != szukana);
+		System.out.println();
+		System.out.println("Brawo! Tą liczbą jest " + szukana);
+		System.out.println("Udało ci się odgadnąć w " + ileProb + " próbie.");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z06_zgadywanka/MaloDuzo_v3.java

+package rozwiazania_zadan.r1.z06_zgadywanka;
+
+import java.util.Scanner;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class MaloDuzo_v3 {
+
+	public static void main(String[] args) {
+		final int LIMIT = 1000;
+		
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		int szukana = ThreadLocalRandom.current().nextInt(LIMIT);
+		
+		System.out.println("Wylosowałem liczbę z zakresu od 0 do " + (LIMIT-1) + ". Spróbuj ją odgadnąć...");
+		
+		int ileProb = 0;
+		int propozycja = -1;
+		while(propozycja != szukana) {
+			ileProb += 1;
+			System.out.println("Wprowadź liczbę: ");
+			propozycja = sc.nextInt();
+			if(propozycja < szukana) {
+				System.out.println("Podana liczba jest zbyt mała.");
+			}
+			if(propozycja > szukana) {
+				System.out.println("Podana liczba jest zbyt duża.");
+			}
+		}
+		System.out.println();
+		System.out.println("Brawo! Tą liczbą jest " + szukana);
+		System.out.println("Udało ci się odgadnąć w " + ileProb + " próbie.");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z06_zgadywanka/Mnozenie_v1.java

+package rozwiazania_zadan.r1.z06_zgadywanka;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class Mnozenie_v1 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);		
+		Random r = new Random();
+		int x = r.nextInt(10) + 1;
+		int y = r.nextInt(10) + 1;
+		
+		int ileProb = 0;
+		int propozycja;
+		do {
+			ileProb++;
+			System.out.print("Ile to jest " + x + " × " + y + " ? ");
+			propozycja = sc.nextInt();
+		} while(propozycja != x*y);
+		System.out.println();
+		System.out.println("Udało ci się odgadnąć w " + ileProb + " próbie.");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z06_zgadywanka/Mnozenie_v2.java

+package rozwiazania_zadan.r1.z06_zgadywanka;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class Mnozenie_v2 {
+
+	public static void main(String[] args) {
+		final int LIMIT = 10;
+		
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		Random r = new Random();
+		final int x = r.nextInt(LIMIT) + 1;
+		final int y = r.nextInt(LIMIT) + 1;
+		final int oczekiwanyWynik = x*y;
+		
+		int ileProb = 1;
+		System.out.print("Ile to jest " + x + " × " + y + " ? ");
+		int propozycja = sc.nextInt();
+		while(propozycja != oczekiwanyWynik) {
+			System.out.print("Źle. Spróbuj jeszcze raz: ");
+			ileProb++;
+			propozycja = sc.nextInt();
+		}
+		System.out.println();
+		System.out.println("Udało ci się odgadnąć w " + ileProb + " próbie.");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z07_skarb/GraSzukanieSkarbu.java

+package rozwiazania_zadan.r1.z07_skarb;
+
+import java.util.Random;
+import java.util.Scanner;
+
+/*
+Napisz grę polegającą na poszukiwaniu skarbu na dwuwymiarowej planszy o rozmiarach 10 na 10.
+Plansza jest wirtualna - nie trzeba ani w pamięci tworzyć żadnych tablic, ani żadnej planszy wyświetlać :)
+
+Program na początku losuje położenie skarbu na planszy (współrzędne x i y)
+oraz początkowe położenie gracza.
+
+Następnie w pętli użytkownik może wprowadzać komendy zmieniające położenie gracza.
+(np. po polsku G D L P, albo po angielsku U D L R, albo konwencja graczy W S A D)
+
+Po każdym ruchu użytkownik powinien otrzymywać informację o tym, czy zmierza w dobrym kierunku.
+
+Wyjście poza planszę oznacza porażkę - koniec gry.
+Wejście przez gracza na pozycję skarbu oznacza wygraną.
+
+Po znalezieniu skarbu program wypisuje gratulacje i informację o liczbie ruchów
+wykorzystanych przez użytkownika na dojście do celu.
+*/
+
+public class GraSzukanieSkarbu {
+	private static final boolean PODPOWIADANIE = true;
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in); // aby czytać polecenia
+		Random random = new Random(); // aby losować
+		
+		int skarb_x = random.nextInt(10); // liczba od 0 do 9
+		int skarb_y = random.nextInt(10);
+		int gracz_x = random.nextInt(10);
+		int gracz_y = random.nextInt(10);
+
+		if(PODPOWIADANIE)
+			System.out.printf("Pozycja skarbu: (%d , %d)\n", skarb_x, skarb_y);
+
+		petla:
+		while(true) {
+			if(PODPOWIADANIE)
+				System.out.printf("\nAktualna pozycja: (%d , %d)\n", gracz_x, gracz_y);
+			
+			int staraOdleglosc = Math.abs(skarb_x - gracz_x) + Math.abs(skarb_y - gracz_y);
+			
+			System.out.println("Podaj ruch [WSAD] lub przerwij [Q]: ");
+			String ruch = sc.nextLine();
+			
+			switch(ruch.trim().toUpperCase()) {
+			case "W" : gracz_y--; break;
+			case "S" : gracz_y++; break;
+			case "A" : gracz_x--; break;
+			case "D" : gracz_x++; break;
+			case "Q" : 
+				System.out.println("Poddajesz się? miękiszon...");
+				break petla; // mówimy, że break odnosi się do pętli oznaczonej tą etykietą
+				
+			default:
+				System.out.println("nie ma takiej komendy");
+				continue petla; // etykiety można podawać także przy instrukcji continue, chociaż w tym konkretnym przypadku nie jest to konieczne
+			}
+			
+			if(gracz_x < 0 || gracz_x > 9 || gracz_y < 0 || gracz_y > 9) {
+				System.out.println("Wypadłeś poza planszę - porażka");
+				break;
+			}
+			
+			if(gracz_x == skarb_x && gracz_y == skarb_y) {
+				System.out.println("Wygrana, gratulacje!");
+				break;
+			}
+			
+			int nowaOdleglosc = Math.abs(skarb_x - gracz_x) + Math.abs(skarb_y - gracz_y);
+			// System.out.println("odległość: " + nowaOdleglosc);
+			if(nowaOdleglosc < staraOdleglosc) {
+				System.out.println("Zbliżasz się do skarbu");
+			} else {
+				System.out.println("Oddalasz się od skarbu");
+			}
+		}
+		
+		System.out.println("\n================================\n  To była gra napisania na kursie ALX\n================================");
+	}
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z08_range/Range.java

+package rozwiazania_zadan.r1.z08_range;
+
+public class Range {
+	
+	private static void wypiszLiczbyUp(int start, int koniec, int krok) {
+		assert krok > 0; // tylko informacyjnie, to nie wpływa na działanie
+		for(int i = start; i < koniec; i += krok) {
+			System.out.print(i + " ");
+		}
+		System.out.println();
+	}
+
+	private static void wypiszLiczbyDown(int start, int koniec, int krok) {
+		assert krok < 0; // tylko informacyjnie, to nie wpływa na działanie
+		for(int i = start; i > koniec; i += krok) {
+			System.out.print(i + " ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		// domyślne wartości w razie braku argumentów
+		int start = 0;
+		int koniec = 0;
+		int krok = 1;
+		
+		if(args.length == 1) {
+			koniec = Integer.parseInt(args[0]);
+		}
+		if(args.length >= 2) {
+			start = Integer.parseInt(args[0]);
+			koniec = Integer.parseInt(args[1]);
+		}
+		if(args.length >= 3) {
+			krok = Integer.parseInt(args[2]);
+		}
+		
+		System.out.println("Ustalone parametry: " + start+ ", " + koniec + ", " + krok);
+		System.out.println();
+		
+		if(krok == 0) {
+			System.out.println("krok nie może być równy 0");
+		} else if(krok > 0) {
+			wypiszLiczbyUp(start, koniec, krok);
+		} else {
+			wypiszLiczbyDown(start, koniec, krok);
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z09_kalkulator/Kalkulator1.java

+package rozwiazania_zadan.r1.z09_kalkulator;
+
+import java.util.Scanner;
+
+public class Kalkulator1 {
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj działanie na zasadzie 12 + 15");
+		
+		double x = sc.nextDouble();
+		String znak = sc.next();
+		double y = sc.nextDouble();
+		
+		switch(znak) {
+		case "+": System.out.println("wynik: " + (x + y)); break;
+		case "-": System.out.println("wynik: " + (x - y)); break;
+		case "*": System.out.println("wynik: " + (x * y)); break;
+		case "/": System.out.println("wynik: " + (x / y)); break;
+		case "%": System.out.println("wynik: " + (x % y)); break;
+		default: System.out.println("Nie ma takiego działania: " + znak);
+		}
+		
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z09_kalkulator/Kalkulator2.java

+package rozwiazania_zadan.r1.z09_kalkulator;
+
+import java.util.Scanner;
+
+public class Kalkulator2 {
+
+	static double oblicz(double arg1, double arg2, String operacja) {
+		switch(operacja) {
+		case "+": return arg1 + arg2;
+		case "-": return arg1 - arg2;
+		case "*": return arg1 * arg2;
+		case "/": return arg1 / arg2;
+		case "%": return arg1 % arg2;
+		default : return 0.0;
+		}
+	}
+	
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj działanie na zasadzie 12 + 15");
+		
+		double x = sc.nextDouble();
+		String znak = sc.next();
+		double y = sc.nextDouble();
+		
+		double wynik = oblicz(x, y, znak);
+		System.out.println("wynik: " + wynik);
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r1/z09_kalkulator/Kalkulator3.java

+package rozwiazania_zadan.r1.z09_kalkulator;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Kalkulator3 {
+
+	static double oblicz(double arg1, double arg2, String operacja) {
+		switch(operacja) {
+		case "+": return arg1 + arg2;
+		case "-": return arg1 - arg2;
+		case "*": return arg1 * arg2;
+		case "/": return arg1 / arg2;
+		case "%": return arg1 % arg2;
+		case "^": return Math.pow(arg1, arg2);
+		default : throw new IllegalArgumentException("Nie ma takiej operacji " + operacja);
+		}
+	}
+	
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		
+		while (true) {
+			System.out.println("Podaj działanie na zasadzie 12 + 15 lub napisz KONIEC");
+
+			if(!sc.hasNextDouble() && sc.nextLine().trim().toLowerCase().equals("koniec")) {
+				break;
+			}
+			
+			try {
+				double x = sc.nextDouble();
+				String znak = sc.next();
+				double y = sc.nextDouble();
+				
+				// Aby Scanner "przeszedł do następnej linii"
+				// (czyli wczytał wszystko co jest za tą liczbą i w następnej linii czekał na dalsze polecenia)
+				sc.nextLine();
+				
+				double wynik = oblicz(x, y, znak);
+				System.out.println("wynik: " + wynik);
+			} catch (Exception e) {
+				System.out.println("Błąd: " + e.getMessage());
+			}
+		}
+		
+		System.out.println("Dziękujemy, papa");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p1_nieparzyste/SumaNieparzystych_v1.java

+package rozwiazania_zadan.r2.z1.p1_nieparzyste;
+
+public class SumaNieparzystych_v1 {
+	
+	static int sumaNieparzystych(int n) {
+		int suma = 0;
+		for(int i = 1; i < 2*n; i+=2) {
+			suma += i;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		System.out.println(sumaNieparzystych(0));
+		System.out.println(sumaNieparzystych(1));
+		System.out.println(sumaNieparzystych(5));
+		System.out.println(sumaNieparzystych(7));
+		System.out.println(sumaNieparzystych(10));
+		System.out.println(sumaNieparzystych(100));
+	}
+
+}
+

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p1_nieparzyste/SumaNieparzystych_v2.java

+package rozwiazania_zadan.r2.z1.p1_nieparzyste;
+
+public class SumaNieparzystych_v2 {
+	
+	static int sumaNieparzystych(int n) {
+		int suma = 0;
+		for(int i = 0; i < n; i++) {
+			suma += 2*i+1;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		System.out.println(sumaNieparzystych(0));
+		System.out.println(sumaNieparzystych(1));
+		System.out.println(sumaNieparzystych(5));
+		System.out.println(sumaNieparzystych(7));
+		System.out.println(sumaNieparzystych(10));
+		System.out.println(sumaNieparzystych(100));
+	}
+
+}
+

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p2_suma_cyfr/SumaCyfr_Matematycznie.java

+package rozwiazania_zadan.r2.z1.p2_suma_cyfr;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Matematycznie {
+	
+	static int sumaCyfr(long liczba) {
+		int suma = 0;
+		while(liczba > 0) {
+			suma += liczba % 10;
+			liczba /= 10;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p2_suma_cyfr/SumaCyfr_Tekstowo1.java

+package rozwiazania_zadan.r2.z1.p2_suma_cyfr;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Tekstowo1 {
+	
+	static int sumaCyfr(long liczba) {
+		String tekstowo = String.valueOf(liczba);
+		int suma = 0;
+		for(char ch : tekstowo.toCharArray()) {
+			if(Character.isDigit(ch)) {
+				suma += Character.digit(ch, 10);
+			}
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p2_suma_cyfr/SumaCyfr_Tekstowo2.java

+package rozwiazania_zadan.r2.z1.p2_suma_cyfr;
+
+import java.util.Scanner;
+
+public class SumaCyfr_Tekstowo2 {
+	
+	static int sumaCyfr(long liczba) {
+		String tekstowo = String.valueOf(liczba);
+		int suma = 0;
+		for(int i = 0; i < tekstowo.length(); i++) {
+			char ch = tekstowo.charAt(i);
+			int wartosc = Integer.parseInt(String.valueOf(ch));
+			suma += wartosc;
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podawaj liczby, a zakończ innym tekstem");
+		while(sc.hasNextLong()) {
+			long liczba = sc.nextLong();
+			int wynik = sumaCyfr(liczba);
+			System.out.println("Suma cyfr tej liczby wynosi " + wynik);
+			System.out.println();
+		}
+
+		System.out.println("pa pa ");
+	}
+
+}
+

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p3_fib/Fibonacci1.java

+package rozwiazania_zadan.r2.z1.p3_fib;
+
+import java.util.Scanner;
+
+public class Fibonacci1 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	// Wersja rekurencyjna, oparta bezpośrednio o definicję matematyczną.
+	// Ta wersja ma złożoność wykładniczą (czyli działa w czasie proporcjonalnym do funkcji wykładniczej / w zasadzie do wartości wyliczanej liczby Fibonacciego)
+	static long fib(int n) {
+		if(n == 0)
+			return 0;
+		if(n == 1)
+			return 1;
+		return fib(n-1) + fib(n-2);
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p3_fib/Fibonacci1_IlustracjaWykladniczejRekurencji.java

+package rozwiazania_zadan.r2.z1.p3_fib;
+
+import java.util.Scanner;
+
+// W tej wersji funkcja wypisuje znaczek na odpowiednim poziomie wcięcia, aby pokazać jak dużo razy jest uruchamiana przy podejściiu rekurencyjnym
+public class Fibonacci1_IlustracjaWykladniczejRekurencji {
+	private static int kolumna_wyrownania = 50;
+	
+	static long fib(int n) {
+		System.out.println(" ".repeat(kolumna_wyrownania-n) + ">");
+		long wynik;
+		if(n == 0) {
+			wynik = 0;
+		} else if(n == 1) {
+			wynik = 1;
+		} else {
+			long res1 = fib(n-1);
+			long res2 = fib(n-2);
+			wynik = res1 + res2;
+		}
+		System.out.println(" ".repeat(kolumna_wyrownania-n) + "<");
+		return wynik;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("\nPodaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			kolumna_wyrownania = liczba;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p3_fib/Fibonacci2.java

+package rozwiazania_zadan.r2.z1.p3_fib;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class Fibonacci2 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static long fib(int n) {
+		long[] f = new long[n+2];
+		f[0] = 0;
+		f[1] = 1;
+		for(int i = 2; i <= n; i++) {
+			f[i] = f[i-2] + f[i-1];
+		}
+		System.out.println("Cała tablica: " + Arrays.toString(f));
+		return f[n];
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p3_fib/Fibonacci3.java

+package rozwiazania_zadan.r2.z1.p3_fib;
+
+import java.util.Scanner;
+
+public class Fibonacci3 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static long fib(int n) {
+		long ostatnia = 0;
+		long przedostatnia = 1;
+		for(int i = 1; i <= n; i++) {
+			long nowa = ostatnia + przedostatnia;
+			przedostatnia = ostatnia;
+			ostatnia = nowa;
+		}
+		return ostatnia;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p3_fib/Fibonacci4.java

+package rozwiazania_zadan.r2.z1.p3_fib;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+
+public class Fibonacci4 {
+	// 0 1 1 2 3 5 8 13 21 34 55
+	
+	static BigInteger fib(int n) {
+		BigInteger ostatnia = BigInteger.ZERO;
+		BigInteger przedostatnia = BigInteger.ONE;
+		for(int i = 1; i <= n; i++) {
+			BigInteger nowa = ostatnia.add(przedostatnia);
+			przedostatnia = ostatnia;
+			ostatnia = nowa;
+		}
+		return ostatnia;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz -1");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			int liczba = sc.nextInt();
+			if(liczba < 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			var wynik = fib(liczba);
+			long k = System.currentTimeMillis();
+			
+			System.out.println("F(" + liczba + ") = " + wynik);
+			System.out.println("Obliczenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p4_pierwsze/LiczbyPierwsze1.java

+package rozwiazania_zadan.r2.z1.p4_pierwsze;
+
+import java.util.Scanner;
+
+public class LiczbyPierwsze1 {
+	// Z definicji liczby pierwszej: to jest taka liczba naturalna, która ma dokładnie 2 dzielniki
+	// (1 i siebie samą, przy czym 1 NIE JEST uznawane za liczbę pierwszą).
+	
+	// Ta wersja sprawdza ile jest dzielników; jeśli 2, to znaczy, że liczba pierwsza.
+	// Wada: długo działa dla dużych liczb. Niezależnie od tego czy liczba jest pierwsza, czy nie, i tak musi dojść do samego końca.
+	
+	static boolean czyPierwsza(long liczba) {
+		long ileDzielnikow = 0;
+		for(long i = 1; i <= liczba; i++) {
+			if(liczba % i == 0) {
+				ileDzielnikow++;
+			}
+		}
+		System.out.println("ilość dzielników: " + ileDzielnikow);
+		return ileDzielnikow == 2; // tylko wtedy liczba jest pierwsza
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz 0");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			long liczba = sc.nextLong();
+			if(liczba == 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			boolean wynik = czyPierwsza(liczba);
+			long k = System.currentTimeMillis();
+			
+			if(wynik) {
+				System.out.println("Liczba " + liczba + " jest pierwsza");
+			} else {
+				System.out.println("Liczba " + liczba + " nie jest pierwsza");
+			}
+			System.out.println("Sprawdzenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p4_pierwsze/LiczbyPierwsze2.java

+package rozwiazania_zadan.r2.z1.p4_pierwsze;
+
+import java.util.Scanner;
+
+public class LiczbyPierwsze2 {
+	// Ta wersja sprawdza czy liczba jest podzielna przez jakąkolwiek liczbę inną niż 1 i ona sama.
+	// Gdyby tak było, to nie jest pierwsza.
+	// Również "1" nie jest l.pierwszą.
+	// Gdy liczba nie jest pierwsza, to pętla jest przerywana szybiej (niż v1). spr np. 2147483648
+	// Jeśli jest pierwsza, to pętla musi dojść do końca, spr. np. 2147483647
+	static boolean czyPierwsza(long liczba) {
+		if(liczba == 1) {
+			return false;
+		}
+		
+		for(long i = 2; i < liczba; i++) {
+			if(liczba % i == 0) {
+				return false; // skoro dzieli się przez jakąś liczbę pośrednią (nie 1 i nią samą), to nie jest pierwsza
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz 0");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			long liczba = sc.nextLong();
+			if(liczba == 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			boolean wynik = czyPierwsza(liczba);
+			long k = System.currentTimeMillis();
+			
+			if(wynik) {
+				System.out.println("Liczba " + liczba + " jest pierwsza");
+			} else {
+				System.out.println("Liczba " + liczba + " nie jest pierwsza");
+			}
+			System.out.println("Sprawdzenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p4_pierwsze/LiczbyPierwsze3.java

+package rozwiazania_zadan.r2.z1.p4_pierwsze;
+
+import java.util.Scanner;
+
+public class LiczbyPierwsze3 {
+	// W tej wersji korzystam z tego, że jeśli liczba ma dzielnik (inny niż 1 i ona sama), to ten dzielnik
+	// musi być <= pierwiastka z tej liczby. Wystarczy więc iść w pętli do pierwiastka.
+	// Porównaj czas działania np. dla 2147483647 z wersją 2.
+	
+	static boolean czyPierwsza(long liczba) {
+		if(liczba == 1) {
+			return false;
+		}
+		
+		for(long i = 2; i <= Math.sqrt(liczba+1); i++) {
+			// wpisałem liczba+1, aby zmniejszyć ryzyko problemów z dokładnością doubli (dla dużych liczb)
+			// jednocześnie jest to poprawne dla początkowych liczb, bo sqrt(3) < 2
+			if(liczba % i == 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz 0");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			long liczba = sc.nextLong();
+			if(liczba == 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			boolean wynik = czyPierwsza(liczba);
+			long k = System.currentTimeMillis();
+			
+			if(wynik) {
+				System.out.println("Liczba " + liczba + " jest pierwsza");
+			} else {
+				System.out.println("Liczba " + liczba + " nie jest pierwsza");
+			}
+			System.out.println("Sprawdzenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z1/p4_pierwsze/LiczbyPierwsze4.java

+package rozwiazania_zadan.r2.z1.p4_pierwsze;
+
+import java.util.Scanner;
+
+public class LiczbyPierwsze4 {
+	
+	// W tej wersji osobno sprawdzam podzielność przez 2 jako "bardzo prawdopodobną sytuację"
+	// Dzięki temu w pętli mogę iść krokiem o 2 sprawdzając tylko liczby nieparzyste
+	// i jeszcze trochę (prawie dwukrotnie) przyspieszam działanie względem wersji 3.
+	static boolean czyPierwsza(long liczba) {
+		if(liczba == 1) {
+			return false;
+		}
+		if(liczba != 2 && liczba % 2 == 0) {
+			return false;
+		}
+		
+		for(long i = 3; i <= Math.sqrt(liczba+1); i += 2) {
+			if(liczba % i == 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Aby zakończyć, wpisz 0");
+		while(true) {
+			System.out.print("Podaj liczbę: ");
+			long liczba = sc.nextLong();
+			if(liczba == 0) break;
+			
+			// pomiar czasu
+			long p = System.currentTimeMillis();
+			boolean wynik = czyPierwsza(liczba);
+			long k = System.currentTimeMillis();
+			
+			if(wynik) {
+				System.out.println("Liczba " + liczba + " jest pierwsza");
+			} else {
+				System.out.println("Liczba " + liczba + " nie jest pierwsza");
+			}
+			System.out.println("Sprawdzenie trwało " + (k-p) + " ms");
+			System.out.println();
+		}
+
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z2_funkcje_na_tablicach/FunkcjeNaTablicach.java

+package rozwiazania_zadan.r2.z2_funkcje_na_tablicach;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class FunkcjeNaTablicach {
+
+	static Integer max(int[] t) {
+		if(t.length == 0) {
+			return null;
+		}
+		int max = Integer.MIN_VALUE;
+		for (int e : t) {
+			if (e > max) {
+				max = e;
+			}
+		}
+		return max;
+	}
+	
+	static Integer min(int[] t) {
+		if(t.length == 0) {
+			return null;
+		}
+		int min = Integer.MAX_VALUE;
+		for (int e : t) {
+			if (e < min) {
+				min = e;
+			}
+		}
+		return min;
+	}
+	
+	static Integer min_v2(int[] t) {
+		if(t.length == 0) {
+			return null;
+		}
+		int min = t[0];
+		for (int i = 1; i < t.length; i++) {
+			if (t[i] < min) {
+				min = t[i];
+			}
+		}
+		return min;
+	}
+	
+	static int roznicaMinMax_v1(int[] t) {
+		// wersja "lepsza" jeśli kryterium oceny jest działanie, wydajność - bo tylko jedno przejście przez dane
+		if(t.length == 0) {
+			return 0;
+		}
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+		for (int e : t) {
+			if (e < min) {
+				min = e;
+			}
+			if (e > max) {
+				max = e;
+			}
+		}
+		return max - min;
+	}
+	
+	
+	static int roznicaMinMax_v2(int[] t) {
+		// wersja "lepsza" jeśli kryterium oceny jest styl, struktura kodu - bo korzystamy z już wcześniej napisanych rzeczy
+		return t.length == 0 ? 0 : max(t) - min(t);
+	}
+	
+
+	static void wypiszWieksze(int[] t, int x) {
+		for (int e : t) {
+			if (e > x) {
+				System.out.print(e + ", ");
+			}
+		}
+		System.out.println();
+	}
+	
+	static Integer pierwszaWieksza(int[] t, int x) {
+		for (int e : t) {
+			if (e > x) {
+				return e;
+			}
+		}
+		return null;
+	}
+	
+	static int sumaWiekszych(int[] t, int x) {
+		int suma = 0;
+		for (int e : t) {
+			if (e > x) {
+				suma += e;
+			}
+		}
+		return suma;
+	}
+	
+	static int ileWiekszych(int[] t, int x) {
+		int ile = 0;
+		for (int e : t) {
+			if (e > x) {
+				ile += 1;
+			}
+		}
+		return ile;
+	}
+	
+
+	static void wypiszPodzielne(int[] t, int x) {
+		for (int e : t) {
+			if (e % x == 0) {
+				System.out.print(e + "; ");
+			}
+		}
+		System.out.println();
+	}
+	
+	static Integer pierwszaPodzielna(int[] t, int x) {
+		for (int e : t) {
+			if (e % x == 0) {
+				return e;
+			}
+		}
+		return null;
+	}
+	
+	static int sumaPodzielnych(int[] t, int x) {
+		int suma = 0;
+		for (int e : t) {
+			if (e % x == 0) {
+				suma += e;
+			}
+		}
+		return suma;
+	}
+	
+	static int ilePodzielnych(int[] t, int x) {
+		int ile = 0;
+		for (int e : t) {
+			if (e % x == 0) {
+				ile++;
+			}
+		}
+		return ile;
+	}
+	
+	
+	static Integer znajdzWspolny(int[] t1, int[] t2) {
+		for (int e1 : t1) {
+			for (int e2 : t2) {
+				if (e1 == e2) {
+					return e1;
+				}
+			}
+		}
+		return null;
+	}
+	
+	static List<Integer> wszystkieWspolne(int[] t1, int[] t2) {
+		List<Integer> lista = new ArrayList<>();
+		for (int e1 : t1) {
+			for (int e2 : t2) {
+				if (e1 == e2) {
+					lista.add(e1);
+				}
+			}
+		}
+		
+		return lista;
+	}
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z2_funkcje_na_tablicach/WersjaStrumieniowa.java

+package rozwiazania_zadan.r2.z2_funkcje_na_tablicach;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.function.IntPredicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/** Ta wersja wykorzystuje strumienie (od Java 8) i gotowe rozwiązania, jeśli są dostępne. */
+public class WersjaStrumieniowa {
+
+	// Tu i w kilku dalej zmieniam typ na OptionalInt, bo to bardziej pasuje do nowoczesnego stylu niż Integer.
+	static OptionalInt max(int[] t) {
+		return IntStream.of(t).max();
+	}
+	
+	static OptionalInt min(int[] t) {
+		return IntStream.of(t).min();
+	}
+	
+	static Integer min_v2(int[] t) {
+		// Gdybyśmy bardzo chcieli zwrócić Integer, a nie OptionalInt
+		OptionalInt opt = IntStream.of(t).min();
+		if(opt.isPresent()) {
+			return opt.getAsInt();
+		} else {
+			return null;
+		}
+	}
+	
+	static int roznicaMinMax(int[] t) {
+		return max(t).orElse(0) - min(t).orElse(0);
+	}
+	
+
+	static void wypiszWieksze(int[] t, int x) {
+		IntStream.of(t)
+			.filter(e -> e > x)
+			.forEachOrdered(e -> System.out.print(e + ", "));
+		System.out.println();
+	}
+	
+	static OptionalInt pierwszaWieksza(int[] t, int x) {
+		return IntStream.of(t)
+			.filter(e -> e > x)
+			.findFirst();
+	}
+	
+	static int sumaWiekszych(int[] t, int x) {
+		return IntStream.of(t)
+				.filter(e -> e > x)
+				.sum();
+	}
+	
+	static long ileWiekszych(int[] t, int x) {
+		return IntStream.of(t)
+				.filter(e -> e > x)
+				.count();
+	}
+	
+	// przykłady z podzielnością wyszłyby bardzo podobne do 4 powyższych, dlatego wprowadzam pewne urozmaicenia
+	
+	private static IntPredicate jestPodzielnaPrzez(int x) {
+		return (int e) -> e % x == 0;
+	}
+
+	static void wypiszPodzielne(int[] t, int x) {
+		IntStream.of(t)
+				.filter(jestPodzielnaPrzez(x))
+				.forEachOrdered(System.out::println);
+	}
+	
+	static OptionalInt pierwszaPodzielna(int[] t, int x) {
+		return IntStream.of(t)
+				.filter(jestPodzielnaPrzez(x))
+				.findFirst();
+	}
+	
+	static int sumaPodzielnych(int[] t, int x) {
+		return IntStream.of(t)
+				.filter(jestPodzielnaPrzez(x))
+				.reduce(0, (a, e) -> a+e); // istnieje też sum
+	}
+	
+	static int ilePodzielnych(int[] t, int x) {
+		return IntStream.of(t)
+				.filter(jestPodzielnaPrzez(x))
+				.reduce(0, (a, e) -> a+1); // istnieje też count
+	}
+	
+	
+	static OptionalInt znajdzWspolny(int[] t1, int[] t2) {
+		return IntStream.of(t1)
+				.flatMap(e1 -> IntStream.of(t2).filter(e2 -> e1 == e2))
+				.findAny();
+	}
+	
+	static List<Integer> wszystkieWspolne(int[] t1, int[] t2) {
+		return IntStream.of(t1)
+				.flatMap(e1 -> IntStream.of(t2).filter(e2 -> e1 == e2))
+				.boxed()
+				.collect(Collectors.toList());
+	}
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z3_funkcje_konwersje/KonwersjeJednostek.java

+package rozwiazania_zadan.r2.z3_funkcje_konwersje;
+/* Tego nie było w naszych zestawach, ale też warto zobaczyć: klasa z metodami statycznymi, czyli "funkcjami". */
+
+public class KonwersjeJednostek {
+	
+	static double cale_na_cm(double cale) {
+		return cale * 2.54;
+	}
+	
+	static double cm_na_cale(double cm) {
+		return cm / 2.54;
+	}
+	
+	static double mile_na_km(double mile) {
+		return mile * 1.609344;
+	}
+	
+	public static double km_na_mile(double km) {
+		return km / 1.609344;
+	}
+	
+	public static double far_na_celc(double far) {
+		// to dawało złe wyniki z poowdu dzielenia całkowitego 5/9 == 0
+		// return 5/9 * (far - 32);
+		
+		// przykładowe dobre rozwiązania
+		// return 5.0 / 9.0 * (far - 32.0);
+		return 5. / 9. * (far - 32.);
+		// return (far - 32) / 1.8;
+		
+		// Jeśli zacznę od zmiennej typu double to będzie OK (Java liczy od lewej do prawej)
+		// return (far - 32) * 5 / 9;
+	}
+	
+	public static double celc_na_far(double cel) {
+		//źle return 32 + 9/5 * cel;
+		
+//		return 32.0 + 9./5. * cel;
+//		return 32 + 1.8 * cel;
+		return cel * 9 / 5 + 32;
+	}
+	
+	public static void main(String[] args) {
+		System.out.println(cale_na_cm(0));
+		System.out.println(cale_na_cm(10));
+		System.out.println(cale_na_cm(17));
+		System.out.println();
+		
+		System.out.println(mile_na_km(100));
+		System.out.println();
+		System.out.println(km_na_mile(100));
+		System.out.println(km_na_mile(160));
+		System.out.println();
+		
+		System.out.println(far_na_celc(0));  // -17.7
+		System.out.println(far_na_celc(100)); // 37.7
+		System.out.println();
+		System.out.println(celc_na_far(0)); // 32
+		System.out.println(celc_na_far(37)); // około 100
+		System.out.println(celc_na_far(100)); // 212
+		
+	}
+	
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z3_funkcje_konwersje/ProgramKonwertujacy.java

+package rozwiazania_zadan.r2.z3_funkcje_konwersje;
+
+import java.util.Scanner;
+
+// Jak uzyć definicji z innej klasy będąc w tym smaym pakiecie?
+// Po prostu uzyć nazwy klasy
+public class ProgramKonwertujacy {
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj nazwę operacji");
+		System.out.println("  m2k - mile na kilometry");
+		System.out.println("  k2m - kilometry na mile");
+		System.out.println("  f2c - Fahrenheity na Celcjusze");
+		System.out.println("  c2f - Celcjusze na Fahrenheity");
+		String operacja = sc.nextLine();
+		
+		System.out.println("Podaj argument:");
+		double arg = sc.nextDouble();
+		
+		double wynik = 0;
+		
+		switch(operacja) {
+		case "m2k" :
+			wynik = KonwersjeJednostek.mile_na_km(arg);
+			break;
+		case "k2m" : 
+			wynik = KonwersjeJednostek.km_na_mile(arg);
+			break;
+		case "f2c" : 
+			wynik = KonwersjeJednostek.far_na_celc(arg);
+			break;
+		case "c2f" : 
+			wynik = KonwersjeJednostek.celc_na_far(arg);
+			break;
+		}
+		
+		System.out.println("Wynik wynosi " + wynik);
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r2/z3_funkcje_konwersje/ProgramKonwertujacy2.java

+package rozwiazania_zadan.r2.z3_funkcje_konwersje;
+
+import static rozwiazania_zadan.r2.z3_funkcje_konwersje.KonwersjeJednostek.celc_na_far;
+import static rozwiazania_zadan.r2.z3_funkcje_konwersje.KonwersjeJednostek.far_na_celc;
+import static rozwiazania_zadan.r2.z3_funkcje_konwersje.KonwersjeJednostek.km_na_mile;
+import static rozwiazania_zadan.r2.z3_funkcje_konwersje.KonwersjeJednostek.mile_na_km;
+
+// albo za jednym zamachem:
+// import static funkcje.KonwersjeJednostek.*;
+
+import java.util.Scanner;
+
+// Jak użyć definicji z innej klasy?
+// Można "zaimportować statycznie".
+public class ProgramKonwertujacy2 {
+
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+		
+		petla:
+		while(true) {
+			System.out.println("Podaj nazwę operacji");
+			System.out.println("  m2k - mile na kilometry");
+			System.out.println("  k2m - kilometry na mile");
+			System.out.println("  f2c - Fahrenheity na Celcjusze");
+			System.out.println("  c2f - Celcjusze na Fahrenheity");
+			System.out.println("  k   - Koniec programu");
+			String operacja = sc.nextLine().trim().toLowerCase();
+			
+			System.out.println("Podaj argument:");
+			double arg = sc.nextDouble();
+			sc.nextLine();
+			
+			double wynik = 0;
+			
+			switch(operacja) {
+			case "k":
+				break petla;
+			case "m2k" :
+				wynik = mile_na_km(arg);
+				break;
+			case "k2m" : 
+				wynik = km_na_mile(arg);
+				break;
+			case "f2c" : 
+				wynik = far_na_celc(arg);
+				break;
+			case "c2f" : 
+				wynik = celc_na_far(arg);
+				break;
+			}
+			System.out.println("Wynik wynosi " + wynik);
+			System.out.println();
+		}
+		System.out.println("papa");
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/AdresPocztowy.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.util.Objects;
+
+public class AdresPocztowy {
+	private String ulica_numer;
+	private String kodPocztowy;
+	private String miasto;
+	
+	public AdresPocztowy(String ulica_numer, String kodPocztowy, String miasto) {
+		this.ulica_numer = ulica_numer;
+		this.kodPocztowy = kodPocztowy;
+		this.miasto = miasto;
+	}
+
+	public String getUlica_numer() {
+		return ulica_numer;
+	}
+
+	public void setUlica_numer(String ulica_numer) {
+		this.ulica_numer = ulica_numer;
+	}
+
+	public String getKodPocztowy() {
+		return kodPocztowy;
+	}
+
+	public void setKodPocztowy(String kodPocztowy) {
+		this.kodPocztowy = kodPocztowy;
+	}
+
+	public String getMiasto() {
+		return miasto;
+	}
+
+	public void setMiasto(String miasto) {
+		this.miasto = miasto;
+	}
+
+	@Override
+	public String toString() {
+		return ulica_numer + " " + kodPocztowy + " " + miasto;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(kodPocztowy, miasto, ulica_numer);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		AdresPocztowy other = (AdresPocztowy) obj;
+		return Objects.equals(kodPocztowy, other.kodPocztowy) && Objects.equals(miasto, other.miasto)
+				&& Objects.equals(ulica_numer, other.ulica_numer);
+	}
+	
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/OgloszeniaPrzyklad.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+public class OgloszeniaPrzyklad {
+
+	public static void main(String[] args) {
+		
+		Sprzedawca jan = new Sprzedawca("Jan", "Kowalski", "321321321", "jan@kowalski.pl", new AdresPocztowy("Jasna 14a", "01-234", "Warszawa"));
+		Sprzedawca adam = new Sprzedawca("Adam", "Malinowski", "123123123", null, null);
+
+		System.out.println(jan);
+		System.out.println(adam);
+		System.out.println();
+		
+		Ogloszenie[] ogloszenia = {
+				new Ogloszenie("Sprzedam lunetę do oglądania planet", 1950, jan),
+				new OgloszenieSamochodowe("Sprzedam Golfa", 15000, jan, "VW", "Golf", 2010, 169000, RodzajNapedu.BENZYNA),
+				new OgloszenieMieszkaniowe("Apartament Lux", 550000, adam, "Warszawa", "Mokotów", 22.5, 3, 1),
+		};
+		
+		for(Ogloszenie ogloszenie : ogloszenia) {
+			System.out.println(" * " + ogloszenie);
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/Ogloszenie.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.util.Objects;
+
+public class Ogloszenie {
+	private String tytul;
+	private int cena;
+	private Sprzedawca sprzedawca;
+	
+	public Ogloszenie(String tytul, int cena, Sprzedawca sprzedawca) {
+		this.tytul = tytul;
+		this.cena = cena;
+		this.sprzedawca = sprzedawca;
+	}
+
+	public String getTytul() {
+		return tytul;
+	}
+
+	public void setTytul(String tytul) {
+		this.tytul = tytul;
+	}
+
+	public int getCena() {
+		return cena;
+	}
+
+	public void setCena(int cena) {
+		this.cena = cena;
+	}
+
+	public Sprzedawca getSprzedawca() {
+		return sprzedawca;
+	}
+
+	public void setSprzedawca(Sprzedawca sprzedawca) {
+		this.sprzedawca = sprzedawca;
+	}
+
+	@Override
+	public String toString() {
+		return tytul + ", cena " + cena + " zł, sprzedawca: " + sprzedawca;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(cena, sprzedawca, tytul);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Ogloszenie other = (Ogloszenie) obj;
+		return cena == other.cena && Objects.equals(sprzedawca, other.sprzedawca) && Objects.equals(tytul, other.tytul);
+	}
+	
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/OgloszenieMieszkaniowe.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.util.Objects;
+
+public class OgloszenieMieszkaniowe extends Ogloszenie {
+	private String miasto, dzielnica;
+	private double metraz;
+	private int pietro, liczbaPokoi;
+	
+	public OgloszenieMieszkaniowe(String tytul, int cena, Sprzedawca sprzedawca, String miasto, String dzielnica,
+			double metraz, int pietro, int liczbaPokoi) {
+		super(tytul, cena, sprzedawca);
+		this.miasto = miasto;
+		this.dzielnica = dzielnica;
+		this.metraz = metraz;
+		this.pietro = pietro;
+		this.liczbaPokoi = liczbaPokoi;
+	}
+
+	public String getMiasto() {
+		return miasto;
+	}
+
+	public void setMiasto(String miasto) {
+		this.miasto = miasto;
+	}
+
+	public String getDzielnica() {
+		return dzielnica;
+	}
+
+	public void setDzielnica(String dzielnica) {
+		this.dzielnica = dzielnica;
+	}
+
+	public double getMetraz() {
+		return metraz;
+	}
+
+	public void setMetraz(double metraz) {
+		this.metraz = metraz;
+	}
+
+	public int getPietro() {
+		return pietro;
+	}
+
+	public void setPietro(int pietro) {
+		this.pietro = pietro;
+	}
+
+	public int getLiczbaPokoi() {
+		return liczbaPokoi;
+	}
+
+	public void setLiczbaPokoi(int liczbaPokoi) {
+		this.liczbaPokoi = liczbaPokoi;
+	}
+
+	@Override
+	public String toString() {
+		return "OgloszenieMieszkaniowe: " + super.toString() + ", miasto= " + miasto + ", dzielnica=" + dzielnica + ", metraz=" + metraz
+				+ ", pietro=" + pietro + ", liczbaPokoi=" + liczbaPokoi;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = super.hashCode();
+		result = prime * result + Objects.hash(dzielnica, liczbaPokoi, metraz, miasto, pietro);
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (!super.equals(obj))
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		OgloszenieMieszkaniowe other = (OgloszenieMieszkaniowe) obj;
+		return Objects.equals(dzielnica, other.dzielnica) && liczbaPokoi == other.liczbaPokoi
+				&& Double.doubleToLongBits(metraz) == Double.doubleToLongBits(other.metraz)
+				&& Objects.equals(miasto, other.miasto) && pietro == other.pietro;
+	}
+	
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/OgloszenieSamochodowe.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.util.Objects;
+
+public class OgloszenieSamochodowe extends Ogloszenie {
+	private String marka, model;
+	private int rocznik;
+	private long stanLicznika;
+	private RodzajNapedu naped;
+	
+	public OgloszenieSamochodowe(String tytul, int cena, Sprzedawca sprzedawca, String marka, String model, int rocznik,
+			long stanLicznika, RodzajNapedu naped) {
+		super(tytul, cena, sprzedawca);
+		this.marka = marka;
+		this.model = model;
+		this.rocznik = rocznik;
+		this.stanLicznika = stanLicznika;
+		this.naped = naped;
+	}
+
+	public String getMarka() {
+		return marka;
+	}
+
+	public void setMarka(String marka) {
+		this.marka = marka;
+	}
+
+	public String getModel() {
+		return model;
+	}
+
+	public void setModel(String model) {
+		this.model = model;
+	}
+
+	public int getRocznik() {
+		return rocznik;
+	}
+
+	public void setRocznik(int rocznik) {
+		this.rocznik = rocznik;
+	}
+
+	public long getStanLicznika() {
+		return stanLicznika;
+	}
+
+	public void setStanLicznika(long stanLicznika) {
+		this.stanLicznika = stanLicznika;
+	}
+	
+	public RodzajNapedu getNaped() {
+		return naped;
+	}
+	
+	public void setNaped(RodzajNapedu naped) {
+		this.naped = naped;
+	}
+
+	@Override
+	public String toString() {
+		return "OgloszenieSamochodowe: " + super.toString() + ", marka=" + marka + ", model=" + model + ", rocznik=" + rocznik + ", stanLicznika="
+				+ stanLicznika + " napęd=" + naped;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = super.hashCode();
+		result = prime * result + Objects.hash(marka, model, rocznik, stanLicznika, naped);
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (!super.equals(obj))
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		OgloszenieSamochodowe other = (OgloszenieSamochodowe) obj;
+		return Objects.equals(marka, other.marka) && Objects.equals(model, other.model) && rocznik == other.rocznik
+				&& stanLicznika == other.stanLicznika && naped == other.naped;
+	}
+	
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/RodzajNapedu.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+public enum RodzajNapedu {
+	BENZYNA,
+	ON,
+	LPG,
+	ELEKRTYK,
+	HYBRYDA;
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/Sprzedawca.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.util.Objects;
+
+public class Sprzedawca {
+	private String imie, nazwisko;
+	private String telefon;
+	private String email;
+	private AdresPocztowy adres;
+	
+	public Sprzedawca(String imie, String nazwisko, String telefon, String email, AdresPocztowy adres) {
+		this.imie = imie;
+		this.nazwisko = nazwisko;
+		this.telefon = telefon;
+		this.email = email;
+		this.adres = adres;
+	}
+
+	public String getImie() {
+		return imie;
+	}
+
+	public void setImie(String imie) {
+		this.imie = imie;
+	}
+
+	public String getNazwisko() {
+		return nazwisko;
+	}
+
+	public void setNazwisko(String nazwisko) {
+		this.nazwisko = nazwisko;
+	}
+
+	public String getTelefon() {
+		return telefon;
+	}
+
+	public void setTelefon(String telefon) {
+		this.telefon = telefon;
+	}
+
+	public String getEmail() {
+		return email;
+	}
+
+	public void setEmail(String email) {
+		this.email = email;
+	}
+
+	public AdresPocztowy getAdres() {
+		return adres;
+	}
+
+	public void setAdres(AdresPocztowy adres) {
+		this.adres = adres;
+	}
+
+	@Override
+	public String toString() {
+		return imie + " " + nazwisko
+				+ (telefon != null ? (", tel. " + telefon) : "")
+				+ (email != null ? (", email " + email) : "")
+				+ (adres != null ? (", adres " + adres) : "");
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(adres, email, imie, nazwisko, telefon);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Sprzedawca other = (Sprzedawca) obj;
+		return Objects.equals(adres, other.adres) && Objects.equals(email, other.email)
+				&& Objects.equals(imie, other.imie) && Objects.equals(nazwisko, other.nazwisko)
+				&& Objects.equals(telefon, other.telefon);
+	}
+	
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/Szkolenie.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public class Szkolenie {
+	private String tytul;
+	private int liczbaGodzin;
+	private int cena;
+	private List<LocalDate> dniSzkoleniowe;
+	
+	public Szkolenie(String tytul, int liczbaGodzin, int cena, List<LocalDate> dniSzkoleniowe) {
+		this.tytul = tytul;
+		this.liczbaGodzin = liczbaGodzin;
+		this.cena = cena;
+		this.dniSzkoleniowe = dniSzkoleniowe;
+	}
+
+	public String getTytul() {
+		return tytul;
+	}
+
+	public void setTytul(String tytul) {
+		this.tytul = tytul;
+	}
+
+	public int getLiczbaGodzin() {
+		return liczbaGodzin;
+	}
+
+	public void setLiczbaGodzin(int liczbaGodzin) {
+		this.liczbaGodzin = liczbaGodzin;
+	}
+
+	public int getCena() {
+		return cena;
+	}
+
+	public void setCena(int cena) {
+		this.cena = cena;
+	}
+
+	public List<LocalDate> getDniSzkoleniowe() {
+		return dniSzkoleniowe;
+	}
+
+	public void setDniSzkoleniowe(List<LocalDate> dniSzkoleniowe) {
+		this.dniSzkoleniowe = dniSzkoleniowe;
+	}
+	
+	@Override
+	public String toString() {
+		return "Szkolenie [tytul=" + tytul + ", liczbaGodzin=" + liczbaGodzin + ", cena=" + cena + ", dniSzkoleniowe="
+				+ dniSzkoleniowe + "]";
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/ogloszenia/SzkolenieProgram.java

+package rozwiazania_zadan.r3.ogloszenia;
+
+import java.time.LocalDate;
+import java.time.format.TextStyle;
+import java.util.List;
+import java.util.Locale;
+
+public class SzkolenieProgram {
+
+	public static void main(String[] args) {
+		Szkolenie kursJavy = new Szkolenie("Java XL", 80, 4500,
+					List.of(LocalDate.of(2023, 3, 7), LocalDate.of(2023, 3, 8), LocalDate.of(2023, 3, 9)));
+
+		System.out.println(kursJavy);
+		Locale locale = new Locale("pl", "PL");
+		
+		for (LocalDate date : kursJavy.getDniSzkoleniowe()) {
+			//System.out.println(date + " to dzień tygodnia " + date.getDayOfWeek());
+			System.out.println(date + " to dzień tygodnia " + date.getDayOfWeek().getDisplayName(TextStyle.FULL, locale));
+		}
+	}
+
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/z3_fraction/Fraction.java

+package rozwiazania_zadan.r3.z3_fraction;
+
+public class Fraction extends Number implements Comparable<Fraction> {
+	private final long nom;
+	private final long denom;
+	
+	public static final Fraction ZERO = Fraction.of(0);
+	public static final Fraction ONE = Fraction.of(1);
+	public static final Fraction HALF = Fraction.of(1, 2);
+	public static final Fraction PERCENT = Fraction.of(1, 100);
+	
+	private Fraction(long nominator, long denominator) {
+		this.nom = nominator;
+		this.denom = denominator;
+	}
+	
+	public static Fraction of(long nominator, long denominator) {
+		if(denominator == 0) {
+			throw new ArithmeticException("denominator zero");
+		}
+		if(denominator < 0) {
+			denominator = -denominator;
+			nominator = -nominator;
+		}
+		return new Fraction(nominator, denominator);
+	}
+
+	public static Fraction of(long whole) {
+		return new Fraction(whole, 1);
+	}
+
+	public long getNominator() {
+		return nom;
+	}
+
+	public long getDenominator() {
+		return denom;
+	}
+	
+	@Override
+	public String toString() {
+		return String.format("%d/%d", nom, denom);
+	}
+
+	// equals i hashCode napisałem sam, ale to absolutnie nie znaczy, że to są najlepsze implementacje na świecie ;)
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		}
+		if (obj == null || obj.getClass() != Fraction.class) {
+			return false;
+		}
+		Fraction that = (Fraction)obj;
+		return this.nom == that.nom && this.denom == that.denom;
+	}
+	
+	@Override
+	public int hashCode() {
+		long mix = 1009 * denom + nom;
+		return (int)mix ^ (int)(mix >> 32);
+	}
+	
+	@Override
+	public int compareTo(Fraction other) {
+		return Long.compare(this.nom * other.denom, other.nom * this.denom);
+	}
+	
+	public Fraction shortened() {
+		if(nom == 0) {
+			return Fraction.ZERO;
+		}
+		final long gcd = Utils.gcd(nom, denom);
+		if(gcd == 1) {
+			return this;
+		}
+		return new Fraction(nom / gcd, denom / gcd);
+	}
+	
+	public Fraction repricodal() {
+		return Fraction.of(denom, nom);
+	}
+	
+	public Fraction negated() {
+		if(nom == 0) {
+			return this;
+		}
+		return new Fraction(-nom, denom);
+	}
+	
+	public Fraction add(Fraction other) {
+		return Fraction.of(this.nom * other.denom + other.nom * this.denom, this.denom * other.denom).shortened();
+	}
+	
+	public Fraction sub(Fraction other) {
+		return this.add(other.negated());
+	}
+
+	public Fraction mul(Fraction other) {
+		return Fraction.of(this.nom * other.nom, this.denom * other.denom).shortened();
+	}
+
+	public Fraction mul(long number) {
+		return Fraction.of(this.nom * number, this.denom).shortened();
+	}
+
+	public Fraction div(Fraction other) {
+		return this.mul(other.repricodal());
+	}
+
+	public Fraction div(long number) {
+		return Fraction.of(this.nom, this.denom * number).shortened();
+	}
+
+	public Fraction pow(int exp) {
+		return Fraction.of(Utils.pow(this.nom, exp), this.denom).shortened();
+	}
+	
+	@Override
+	public double doubleValue() {
+		return (double)nom / (double)denom;
+	}
+	
+	@Override
+	public float floatValue() {
+		return (float)nom / (float)denom;
+	}
+	
+	@Override
+	public long longValue() {
+		return nom / denom;
+	}
+	
+	@Override
+	public int intValue() {
+		return (int)longValue();
+	}
+}

PC21-JavaUzupelnienia/src/rozwiazania_zadan/r3/z3_fraction/Utils.java

+package rozwiazania_zadan.r3.z3_fraction;
+
+final class Utils {
+	private Utils() { }
+	
+	/** Największy wspólny dzielnik. Implementacja wg poprawionego algorytmu Euklidesa (z modulo zamiast odejmowania).
+	 * @param a liczba całkowita
+	 * @param b liczba całkowita
+	 * @return największy wspólny dzielnik <var>a</var> i <var>b</var>
+	 */
+	static long gcd(long a, long b) {
+		if (a == 0 || b == 0) {
+			throw new IllegalArgumentException("gcd argument zero");
+		}
+		while (b != 0) {
+			long old_b = b;
+			b = a % b;
+			a = old_b;
+		}
+		return a;
+	}
+
+	/** Najmniejsza wspólna wielokrotność.
+	 * @param a liczba całkowita
+	 * @param b liczba całkowita
+	 * @return najmniejsza dodatnia wspólna wielokrotność <var>a</var> i <var>b</var>
+	 */
+	static long lcm(long a, long b) {
+		if (a == 0 || b == 0) {
+			throw new IllegalArgumentException("lcm argument zero");
+		}
+		a = Math.abs(a);
+		b = Math.abs(b);
+		return a / gcd(a, b) * b;
+	}
+
+	/** Potęgowanie liczb całkowitych.
+	 * @param base podstawa
+	 * @param exp wykładnik
+	 * @return <var>base</var> do potęgi <var>exp</var>
+	 */
+	public static long pow(long base, int exp) {
+		long result = 1L;
+		for (int i = 1; i <= exp; i++) {
+			result *= base;
+		}
+		return result;
+	}
+	
+}