rozwiązania prac domowych

src/domowe/r1/z01_ziemniaki/Zakupy1.java

+package domowe.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);
+	}
+
+}

src/domowe/r1/z01_ziemniaki/Zakupy2.java

+package domowe.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ł");
+	}
+
+}

src/domowe/r1/z01_ziemniaki/Zakupy3.java

+package domowe.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.");
+		}
+	}
+
+}

src/domowe/r1/z02_trojkat/Trojkat1.java

+package domowe.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");
+		}
+	}
+
+}

src/domowe/r1/z02_trojkat/Trojkat2_WersjaZFunkcjami.java

+package domowe.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;
+	}
+
+}

src/domowe/r1/z03_szewc/Szewc0.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc0 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+        int koniec = poczatek + czasNaprawy;
+        JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień nr " + koniec);
+        // Ta wersja działa poprawnie tylko w zakresie jednego tygodnia.
+        // Jeśli wynik wychodzi > 7, to nie zostanie sprowadzony do zakresu 1-7.
+    }
+
+}

src/domowe/r1/z03_szewc/Szewc1.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc1 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        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 dzień nr " + koniec);
+    }
+
+}

src/domowe/r1/z03_szewc/Szewc2.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc2 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+        int koniec = (poczatek + czasNaprawy - 1) % 7 + 1; // wynikiem jest liczba od 1 do 7
+        JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień nr " + koniec);
+    }
+
+}

src/domowe/r1/z03_szewc/Szewc3.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc3 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+        int koniec = (poczatek + czasNaprawy - 1) % 7 + 1; // wynikiem jest liczba od 1 do 7
+        JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień nr " + koniec);
+        
+        if(koniec == 1) {
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+        }
+        if(koniec == 2) {
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
+        }
+        if(koniec == 3) {
+            JOptionPane.showMessageDialog(null, "To jest środa");
+        }
+        if(koniec == 4) {
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
+        }
+        if(koniec == 5) {
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+        }
+        if(koniec == 6) {
+            JOptionPane.showMessageDialog(null, "To jest sobota");
+        }
+        if(koniec == 7) {
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
+        }
+    }
+
+}

src/domowe/r1/z03_szewc/Szewc4.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc4 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+        int koniec = (poczatek + czasNaprawy - 1) % 7 + 1; // wynikiem jest liczba od 1 do 7
+        JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień nr " + koniec);
+        
+        switch(koniec) {
+            case 1 ->
+                JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+            case 2 ->
+                JOptionPane.showMessageDialog(null, "To jest wtorek");
+            case 3 ->
+                JOptionPane.showMessageDialog(null, "To jest środa");
+            case 4 ->
+                JOptionPane.showMessageDialog(null, "To jest czwartek");
+            case 5 -> {
+                JOptionPane.showMessageDialog(null, "To jest piątek");
+                JOptionPane.showMessageDialog(null, "Weekendu początek");
+            }
+            case 6 ->
+                JOptionPane.showMessageDialog(null, "To jest sobota");
+            case 7 ->
+                JOptionPane.showMessageDialog(null, "To jest niedziela");
+            default ->
+                JOptionPane.showMessageDialog(null, "Niepoorawny numer " + koniec, "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+}

src/domowe/r1/z03_szewc/Szewc99.java

+package domowe.r1.z03_szewc;
+
+import javax.swing.JOptionPane;
+
+public class Szewc99 {
+
+    public static void main(String[] args) {
+        int poczatek = Integer.parseInt(JOptionPane.showInputDialog("Którego dnia oddajesz buty do naprawy? [1-7]"));
+        int czasNaprawy = Integer.parseInt(JOptionPane.showInputDialog("Ile dni potrwa naprawa?"));
+        int koniec = poczatek + czasNaprawy;
+        JOptionPane.showMessageDialog(null, "Buty będą do odbioru w dzień nr " + koniec);
+       
+        if(koniec == 1 || koniec == 8 || koniec == 15) {
+            JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+        }
+        if(koniec == 2 || koniec == 9 || koniec == 16) {
+            JOptionPane.showMessageDialog(null, "To jest wtorek");
+        }
+        if(koniec == 3 || koniec == 10 || koniec == 17) {
+            JOptionPane.showMessageDialog(null, "To jest środa");
+        }
+        if(koniec == 4 || koniec == 11 || koniec == 18) {
+            JOptionPane.showMessageDialog(null, "To jest czwartek");
+        }
+        if(koniec == 5 || koniec == 12 || koniec == 19) {
+            JOptionPane.showMessageDialog(null, "To jest piątek");
+        }
+        if(koniec == 6 || koniec == 13 || koniec == 20) {
+            JOptionPane.showMessageDialog(null, "To jest sobota");
+        }
+        if(koniec == 7 || koniec == 14 || koniec == 21) {
+            JOptionPane.showMessageDialog(null, "To jest niedziela");
+        }
+        
+    }
+
+}

src/domowe/r1/z04_remont/FirmaRemontowa1.java

+package domowe.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ł");
+	}
+
+}

src/domowe/r1/z04_remont/FirmaRemontowa2.java

+package domowe.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));
+	}
+
+}

src/domowe/r1/z04_remont/FirmaRemontowa3.java

+package domowe.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;
+	}
+
+}

src/domowe/r2/z02_choinka/Choinka1.java

+package domowe.r2.z02_choinka;
+
+import java.util.Scanner;
+
+public class Choinka1 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj wysokość choinki: ");
+        int wys = scanner.nextInt();
+        
+        for(int i = 1; i <= wys; i++) {
+            for(int j = 1; j <= wys-i; j++) {
+                System.out.print(" ");
+            }
+            for(int j = 1; j <= 2*i-1; j++) {
+                System.out.print("*");
+            }
+            System.out.println();
+        }
+    }
+
+}

src/domowe/r2/z02_choinka/Choinka2.java

+package domowe.r2.z02_choinka;
+
+import java.util.Scanner;
+
+public class Choinka2 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj wysokość choinki: ");
+        int wys = scanner.nextInt();
+        
+        int ile_sp = wys;
+        int ile_gw = 1;
+        for(int i = 0; i < wys; i++) {
+            for(int j = 0; j < ile_sp; j++) {
+                System.out.print(" ");
+            }
+            for(int j = 0; j < ile_gw ; j++) {
+                System.out.print("*");
+            }
+            System.out.println();
+            ile_sp -= 1;
+            ile_gw += 2;
+        }
+    }
+
+}

src/domowe/r2/z02_choinka/Choinka3.java

+package domowe.r2.z02_choinka;
+
+import java.util.Scanner;
+
+public class Choinka3 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj wysokość choinki: ");
+        int wys = scanner.nextInt();
+        
+        for(int i = 0; i < wys; i++) {
+            System.out.println(" ".repeat(wys-i) + "*".repeat(2*i+1));
+        }
+    }
+
+}

src/domowe/r2/z02_choinka/Choinka4.java

+package domowe.r2.z02_choinka;
+
+import java.util.Scanner;
+
+public class Choinka4 {
+
+    public static void main(String[] args) {
+        final String TLO = ".";
+        final String ZNAK = "^";
+        
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj wysokość choinki: ");
+        int wys = scanner.nextInt();
+        
+        for(int i = 0; i < wys; i++) {
+            System.out.println(TLO.repeat(wys-i) + ZNAK.repeat(2*i+1) + TLO.repeat(wys-i));
+        }
+    }
+
+}

src/domowe/r2/z03_funkcje/Fib1.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class Fib1 {
+    
+    static long fib(int n) {
+        if(n < 0)
+            throw new IllegalArgumentException("fib nie działa dla ujemnych!");
+        if(n == 0) return 0;
+        if(n == 1) return 1;
+        return fib(n-2) + fib(n-1);
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        while(true) {
+            System.out.print("Podaj argument: ");
+            int n = scanner.nextInt();
+            if(n < 0)
+                break;
+            long p = System.nanoTime();
+            var wynik = fib(n);
+            long k = System.nanoTime();
+            System.out.printf("F(%d) = %d\n", n, wynik);
+            System.out.printf("    czas: %.6f s\n", (k-p)*1e-9);
+        }
+    }
+
+}

src/domowe/r2/z03_funkcje/Fib2.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class Fib2 {
+    
+    static long fib(int n) {
+        long wynik = 0;
+        long poprz = 1;
+        for(int i = 0; i < n; i++) {
+            long nowy = wynik + poprz;
+            poprz = wynik;
+            wynik = nowy;
+        }
+        return wynik;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        while(true) {
+            System.out.print("Podaj argument: ");
+            int n = scanner.nextInt();
+            if(n < 0)
+                break;
+            long p = System.nanoTime();
+            var wynik = fib(n);
+            long k = System.nanoTime();
+            System.out.printf("F(%d) = %d\n", n, wynik);
+            System.out.printf("    czas: %.6f s\n", (k-p)*1e-9);
+        }
+    }
+
+}

src/domowe/r2/z03_funkcje/Fibonacci1.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/Fibonacci1_IlustracjaWykladniczejRekurencji.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/Fibonacci2.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/Fibonacci3.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/Fibonacci4.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/LiczbyPierwsze1.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/LiczbyPierwsze2.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/LiczbyPierwsze3.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/LiczbyPierwsze4.java

+package domowe.r2.z03_funkcje;
+
+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();
+		}
+
+	}
+
+}

src/domowe/r2/z03_funkcje/Silnia1.java

+package domowe.r2.z03_funkcje;
+
+import java.util.Scanner;
+
+public class Silnia1 {
+    
+    static long silnia(int n) {
+        long iloczyn = 1;
+        for(int i = 1; i <= n; i++) {
+            iloczyn *= i;
+        }
+        
+        return iloczyn;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        while(true) {
+            System.out.print("Podaj argument: ");
+            int n = scanner.nextInt();
+            if(n < 0)
+                break;
+            var wynik = silnia(n);
+            System.out.printf("%d! = %s\n", n, wynik);
+        }
+    }
+
+}

src/domowe/r2/z03_funkcje/SilniaBig.java

+package domowe.r2.z03_funkcje;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+
+public class SilniaBig {
+    
+    static BigInteger silnia(int n) {
+        BigInteger iloczyn = BigInteger.ONE;
+        for(int i = 1; i <= n; i++) {
+            iloczyn = iloczyn.multiply(BigInteger.valueOf(i));
+        }
+        
+        return iloczyn;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        while(true) {
+            System.out.print("Podaj argument: ");
+            int n = scanner.nextInt();
+            if(n < 0)
+                break;
+            var wynik = silnia(n);
+            System.out.printf("%d! = %s\n", n, wynik);
+        }
+    }
+
+}

src/domowe/r2/z03_funkcje/SilniaRozneWersje.java

+package domowe.r2.z03_funkcje;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+import java.util.stream.LongStream;
+
+public class SilniaRozneWersje {
+	// Funkcja oblicza silnię z liczby n.
+	// silnia to jest iloczyn kolejnych liczb od 1 do n
+	// np. silnia(5) = 1*2*3*4*5 = 120
+	// W matematyce silnię zapisuje się znakiem ! , np. 5! = 120
+	// silnia ma ważne zastosowania w kombinatoryce
+	static int silnia(int n) {
+		int wynik = 1;
+		for(int i = 1; i <= n; i++) {
+			wynik = wynik * i;
+		}
+		return wynik;
+	}
+	
+	// alternatywne wersje silni
+	// wersja dla typu long, z drobnymi optymalizacjami zapisu
+	static long silniaLong(int n) {
+		long wynik = 1;
+		for(int i = 2; i <= n; i++) {
+			wynik *= i;
+		}
+		return wynik;
+	}
+	
+	// wersja ze zmniejszaniem licznika
+	static long silniaWhile(int n) {
+		long wynik = 1;
+		while(n > 1) {
+			wynik *= n;
+			n--;
+		}
+		return wynik;
+	}
+	
+	// wersja rekurencyjna
+	// rekurencja (recursion) to jest sytuacja, gdy funkcja wywołuje samą siebie
+	static long silniaRek(int n) {
+		if(n <= 1) return 1;
+		return n * silniaRek(n-1);
+	}
+	
+	static BigInteger silniaBig(int n) {
+		BigInteger wynik = BigInteger.ONE;
+		for(int i = 1; i <= n; i++) {
+			wynik = wynik.multiply(BigInteger.valueOf(i));
+		}
+		return wynik;
+	}
+	
+	// Od Javy 8 dostępne są rozwiązania "funkcyjne", m.in. strumienie (Stream) i wyrażenia lambda.
+	// Za ich pomocą obliczenia można zapisywać w zupełnie inny sposób.
+	
+	static long silniaFun(int n) {
+		return LongStream.rangeClosed(2, n).reduce(1, (x, y) -> x*y);
+	}
+	
+	static BigInteger silniaBigFun(int n) {
+		return LongStream.rangeClosed(1, n)
+				.mapToObj(BigInteger::valueOf)
+				.reduce(BigInteger.ONE, BigInteger::multiply);
+	}
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podawaj liczby dodatnie, a zakończ podając liczbę ujemną.");
+		
+		while(true) {
+			System.out.print("\nPodaj liczbę: ");
+			int n = scanner.nextInt();
+			if(n < 0) break;
+			System.out.println("  int: " + n + "! = " + silnia(n));
+			System.out.println(" long: " + n + "! = " + silniaLong(n));
+			System.out.println("while: " + n + "! = " + silniaWhile(n));
+			System.out.println("  rek: " + n + "! = " + silniaRek(n));
+			System.out.println("  big: " + n + "! = " + silniaBig(n));
+			System.out.println("  fun: " + n + "! = " + silniaFun(n));
+			System.out.println(" bfun: " + n + "! = " + silniaBigFun(n));
+		}
+	}
+
+}

src/domowe/r2/z03_funkcje/SumaCyfr_Matematycznie.java

+package domowe.r2.z03_funkcje;
+
+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 ");
+	}
+
+}
+

src/domowe/r2/z03_funkcje/SumaCyfr_Tekstowo1.java

+package domowe.r2.z03_funkcje;
+
+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 ");
+	}
+
+}
+

src/domowe/r2/z03_funkcje/SumaCyfr_Tekstowo2.java

+package domowe.r2.z03_funkcje;
+
+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 ");
+	}
+
+}
+

src/domowe/r2/z03_funkcje/SumaNieparzystych_v1.java

+package domowe.r2.z03_funkcje;
+
+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));
+	}
+
+}
+

src/domowe/r2/z03_funkcje/SumaNieparzystych_v2.java

+package domowe.r2.z03_funkcje;
+
+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));
+	}
+
+}
+

src/domowe/r2/z07_skarb/GraSzukanieSkarbu.java

+package domowe.r2.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================================");
+	}
+}

src/domowe/r2/z08_range/Range.java

+package domowe.r2.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);
+		}
+	}
+
+}

src/domowe/r2/z09_kalkulator/Kalkulator1.java

+package domowe.r2.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);
+		}
+		
+	}
+
+}

src/domowe/r2/z09_kalkulator/Kalkulator2.java

+package domowe.r2.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);
+	}
+
+}

src/domowe/r2/z09_kalkulator/Kalkulator3.java

+package domowe.r2.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");
+	}
+
+}

src/domowe/r2/z2_funkcje_na_tablicach/FunkcjeNaTablicach.java

+package domowe.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;
+	}
+}

src/domowe/r2/z2_funkcje_na_tablicach/WersjaStrumieniowa.java

+package domowe.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());
+	}
+}

src/domowe/r2/z3_funkcje_konwersje/KonwersjeJednostek.java

+package domowe.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
+		
+	}
+	
+
+}

src/domowe/r2/z3_funkcje_konwersje/ProgramKonwertujacy.java

+package domowe.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);
+	}
+
+}

src/domowe/r2/z3_funkcje_konwersje/ProgramKonwertujacy2.java

+package domowe.r2.z3_funkcje_konwersje;
+
+import static domowe.r2.z3_funkcje_konwersje.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");
+	}
+
+}

src/domowe/r3/ogloszenia/AdresPocztowy.java

+package domowe.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);
+	}
+	
+}

src/domowe/r3/ogloszenia/OgloszeniaPrzyklad.java

+package domowe.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);
+		}
+	}
+
+}

src/domowe/r3/ogloszenia/Ogloszenie.java

+package domowe.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);
+	}
+	
+}

src/domowe/r3/ogloszenia/OgloszenieMieszkaniowe.java

+package domowe.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;
+	}
+	
+}

src/domowe/r3/ogloszenia/OgloszenieSamochodowe.java

+package domowe.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;
+	}
+	
+}

src/domowe/r3/ogloszenia/RodzajNapedu.java

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

src/domowe/r3/ogloszenia/Sprzedawca.java

+package domowe.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);
+	}
+	
+}

src/domowe/r3/ogloszenia/Szkolenie.java

+package domowe.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 + "]";
+	}
+
+}

src/domowe/r3/ogloszenia/SzkolenieProgram.java

+package domowe.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));
+		}
+	}
+
+}

src/domowe/r3/pracownik/Pracownik.java

+package domowe.r3.pracownik;
+
+public class Pracownik {
+	private int stawka;
+	private int sumaGodzin = 0;
+	private int sumaNadgodzin = 0;
+
+	public Pracownik(int stawka) {
+		this.stawka = stawka;
+	}
+
+	public void praca(int godziny) {
+		if(godziny > 8) {
+			sumaGodzin += 8;
+			sumaNadgodzin += (godziny - 8);
+		} else {
+			sumaGodzin += godziny;
+		}
+	}
+
+	public int wyplata() {
+		try {
+			return sumaGodzin * stawka + sumaNadgodzin * stawka * 2;
+		} finally {
+			sumaGodzin = 0;
+			sumaNadgodzin = 0;
+		}
+	}
+	
+}

src/domowe/r3/pracownik/PracownikPremia.java

+package domowe.r3.pracownik;
+
+public class PracownikPremia extends Pracownik {
+	private int sumaPremii = 0;
+	
+	public PracownikPremia(int stawka) {
+		super(stawka);
+	}
+
+	public void premia(int kwota) {
+		sumaPremii += kwota;
+	}
+	
+	@Override
+	public int wyplata() {
+		try {
+			return super.wyplata() + sumaPremii;
+		} finally {
+			sumaPremii = 0;
+		}
+	}
+
+}

src/domowe/r3/z3_fraction/Fraction.java

+package domowe.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();
+	}
+}

src/domowe/r3/z3_fraction/Utils.java

+package domowe.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;
+	}
+	
+}