Rozwiązania zadań domowych

src/main/java/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);
+	}
+
+}

src/main/java/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ł");
+	}
+
+}

src/main/java/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.");
+		}
+	}
+
+}

src/main/java/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");
+		}
+	}
+
+}

src/main/java/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;
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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");
+		}
+	}
+
+}

src/main/java/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;
+		}
+		
+		
+	}
+
+}

src/main/java/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);
+		
+	}
+
+}

src/main/java/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;
+		}
+	}
+
+}

src/main/java/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 +".");
+
+	}
+
+}

src/main/java/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";
+		}
+	}
+
+}

src/main/java/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);
+		}
+	}
+
+}

src/main/java/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ł");
+	}
+
+}

src/main/java/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));
+	}
+
+}

src/main/java/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;
+	}
+
+}

src/main/java/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();
+		}
+	}
+
+}

src/main/java/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;
+			}
+		}
+	}
+
+}

src/main/java/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.");
+	}
+
+}

src/main/java/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.");
+	}
+
+}

src/main/java/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.");
+	}
+
+}

src/main/java/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.");
+	}
+
+}

src/main/java/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================================");
+	}
+}

src/main/java/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);
+		}
+	}
+
+}

src/main/java/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);
+		}
+		
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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));
+	}
+
+}
+

src/main/java/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));
+	}
+
+}
+

src/main/java/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 ");
+	}
+
+}
+

src/main/java/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 ");
+	}
+
+}
+

src/main/java/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 ");
+	}
+
+}
+

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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();
+		}
+
+	}
+
+}

src/main/java/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;
+	}
+}

src/main/java/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());
+	}
+}

src/main/java/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
+		
+	}
+	
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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");
+	}
+
+}