From 19a0f6f12e93d6491605197e8683a8b9e06a2307 Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Wed, 6 Jun 2018 22:18:09 +0000
Subject: [PATCH 1/5] Plik zad02

---
 MainApp.java | 282 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 282 insertions(+)
 create mode 100644 MainApp.java

diff --git a/MainApp.java b/MainApp.java
new file mode 100644
index 0000000..56ab965
--- /dev/null
+++ b/MainApp.java
@@ -0,0 +1,282 @@
+//package com.madrakrystian.algebra;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class MainApp {
+
+	
+//	Napisać program, który dla danego pierścienia współczynników R = ℤ/nℤ, n ∈ ℕ oraz wielomianów f,g ∈ R[x] zmiennej x znajdzie:
+//
+//	    iloczyn f⋅g ∈ R[x]
+//	    klasę reszty f ∈ R[x]/(g)
+//	    największy wspólny dzielnik nwd(f,g) korzystając z algorytmu Euklidesa.
+//
+//	Uwaga: wielomiany są podawane jako ciąg współczynników od wyrazu wolnego, do współczynnika wiodącego.
+//
+//	Termin: 07.06
+//	Przykłady:
+//
+//	    Input: 2, [1,1,1,0,1], [0,1,1] (i.e. f = 1 + x + x² + x⁴, g = x² + x)
+//	    Output: [[0,1,0,0,1,1,1], [1,1], [1,1]]
+//
+//	    Input: 6, [2,1,0,2,1,3], [1,0,0,5]
+//	    Output: [[3,1,0,5,0,1,4,5,5], [5,2,1], DivisionError]
+
+
+// Input w programie dla przykladu 1
+//	Podaj n: 
+//		2
+//		Pierwszy wielomian: 
+//		Podaj liczbe wyrazow w wielomianie: 
+//		5
+//		Podaj kolejne wyrazy wielomianu po przycisku enter
+//		1
+//		1
+//		1
+//		0
+//		1
+//		Drugi wielomian: 
+//		Podaj liczbe wyrazow w wielomianie: 
+//		3
+//		Podaj kolejne wyrazy wielomianu po przycisku enter
+//		0
+//		1
+//		1
+	
+	
+	
+	// czytanie inputu z System.in
+	static Scanner reader = new Scanner(System.in);  
+	
+	public static void main(String[] args) {
+		
+		// wielomiany
+		int polyOne[];
+		int polyTwo[];
+
+		// wspolczynnik n
+		int n=1;
+	
+		//input
+		do{
+			System.out.println("Podaj n: ");
+			// wpisz liczbe
+			n = reader.nextInt();
+
+		}while(n > 1000 || n <= 0);
+		
+		
+		System.out.println("Pierwszy wielomian: ");
+		polyOne = fillPolynomial();
+		
+		System.out.println("Drugi wielomian: ");
+		polyTwo = fillPolynomial();
+		
+		// wyswietl wielomiany
+		System.out.println("f:" + Arrays.toString(polyOne));
+		System.out.println("g:" + Arrays.toString(polyTwo));
+		
+		// 1.
+		System.out.println("1. iloczyn f*g: ");
+		int res[] = modTheTab(polynomialsMultiplication(polyOne, polyTwo),n);
+		System.out.println(Arrays.toString(res));
+		
+		// 2.
+		System.out.println("2. klasa reszty: ");
+		res = polynomialsDivide(polyOne,polyTwo,n);
+		System.out.println(Arrays.toString(res));
+		
+		// 3.
+		System.out.println("3. nwd: ");
+		res = nwd(polyOne,polyTwo,n);
+		System.out.println(Arrays.toString(res));
+		
+		reader.close();
+	}
+
+	
+	// uzupelnianie tablicy
+	public static int[] fillPolynomial() {
+		
+		// zmienna pomocnicza 
+		int temp = 0;
+		
+		System.out.println("Podaj liczbe wyrazow w wielomianie: ");
+		temp = reader.nextInt();
+		
+		int[] tab = new int[temp];
+		
+		// uzupelnianie pierwszego wielomianu
+		System.out.println("Podaj kolejne wyrazy wielomianu po przycisku enter");
+
+		for(int i=0; i<tab.length; i++){
+			
+			temp = reader.nextInt();
+			
+			tab[i] = temp;
+		}
+		return tab;
+	}
+	
+	// dzielenie modulo tablicy
+	public static int[] modTheTab(int tab[], int mod) {
+		
+		for(int i=0; i<tab.length; i++) {
+			tab[i] = tab[i] % mod;
+		}
+		return tab;
+	}
+	
+	// 1. mnozenie wielomianow
+	public static int[] polynomialsMultiplication(int polyOne[], int polyTwo[]) {
+		
+		// suma dlugosci
+		int amount = polyOne.length + polyTwo.length;
+		
+		// nowa tablica bedzie dlugosci sumy poteg wyrazow wiodacych obu tablic -1
+		int result[] = new int[amount-1];
+		
+		// wypelnienie nowej tablicy zerami
+		for(int i=0; i<result.length; i++) {
+			result[i] = 0;
+		}
+		// mnozenie
+		for(int i=0; i<polyOne.length; i++) {
+			
+			for(int j=0; j<polyTwo.length; j++) {
+				result[i+j] += polyOne[i] * polyTwo[j];
+			}
+		}
+		return result;
+	}
+	
+	public static int[] polynomialMultiplication(int poly[], int number) {
+		
+		for(int i=0; i<poly.length; i++) {
+			poly[i] *= number;
+		}
+		
+		return poly;
+	}
+	
+	public static int[] polynomialsSubstraction(int polyOne[], int polyTwo[]) {
+		
+		int result[] = Arrays.copyOf(polyOne, polyOne.length);
+		
+		// wypelnienie tablicy zerami
+		for(int i=0; i<result.length; i++) {
+			result[i] = 0;
+		}
+		
+		for(int i=0; i<polyOne.length; i++) {
+			result[i] = polyOne[i] - polyTwo[i];
+		}
+		
+		return result;
+	}
+	
+	public static int multiplier(int lo, int lt, int mod) {
+		
+		for(int i=0; i<mod; i++) {
+		
+			if(lo ==  (lt*i) % mod) {
+				return i;
+			}
+		}
+		
+		// error
+		return -1;
+	}
+
+	public static int[] polynomialShift(int poly[], int places) {
+			
+		// jesli przesunac w lewo o 0 to kopiuj tablice
+		if(places == 0) {
+			int[] res = Arrays.copyOf(poly, poly.length);
+			return res;
+		}
+		// bardzo brzydkie przesuwanie
+		else {
+			int[] res = new int[poly.length];
+			
+			for(int i=0; i<poly.length-places; i++) {
+				res[i] = poly[i+places];
+			}
+			
+			for(int j=poly.length - places + 1; j<res.length; j++) {
+				res[j]=0;
+			}
+			
+			return res;
+		}
+	}
+	
+	//2. Dzielenie wielomianow
+	public static int[] polynomialsDivide(int polyOne[], int polyTwo[], int mod) {
+		
+		// druga tablica ale z rowna liczba indeksow co pierwsza
+		int[] tempTab = new int[polyOne.length];
+		// output
+		int[] result;
+		
+		// wypelnienie tablicy zerami
+		for(int i=0; i<tempTab.length; i++) {
+			tempTab[i] = 0;
+		}
+		
+		// wypelnienie tablicy od konca elementami z konca drugiego wielomianu
+		for(int j=0; j<polyTwo.length; j++) {
+			tempTab[tempTab.length - 1 - j] = polyTwo[polyTwo.length - 1 - j];
+		}
+		
+		// stopnie wielomianow
+		int pod = polyOne.length-1;
+		int ptd = polyTwo.length-1;
+		
+		// liczba przez ktora bedziemy mnozyc tablice
+		int temp,i=0;
+		
+		// dopóki wielomian w ostatnim rzędzie nie będzie stopnia mniejszego niż stopień dzielnika
+		while(pod >= ptd) {
+			
+			// modulo dla ujemnych
+			if(polyOne[pod]<0) {
+				polyOne[pod] = mod + polyOne[pod];
+			}
+			
+			// szukany mnoznik
+			temp =  multiplier(polyOne[pod], polyTwo[ptd], mod);
+			
+			// przesuniecie tablicy
+			tempTab = polynomialShift(tempTab,i);
+			
+			// mnozenie wielomianow
+			tempTab = polynomialMultiplication(tempTab, temp);
+			
+			tempTab = modTheTab(tempTab, mod);
+			
+			// odejmowanie wielomianow
+			polyOne = polynomialsSubstraction(polyOne,tempTab);
+			
+			// zmiejszamy stopien pierwszego wielomianu
+			pod--;
+			
+			// zwiekszamy liczbe przesuniec drugiej tablicy
+			i++;
+			
+		}
+		result = Arrays.copyOf(polyOne, i-1);
+		
+		return result;
+	}
+	
+	// 3.
+	public static int[] nwd(int polyOne[], int polyTwo[], int mod) {
+		if(polyTwo.length == 0) {
+			return polyOne;
+		}
+		return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
+	}
+		
+}
\ No newline at end of file
-- 
2.20.1


From 9d1452fa164159ab97a849daf40203c64a62ed10 Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Wed, 6 Jun 2018 22:20:32 +0000
Subject: [PATCH 2/5] Plik zad01

---
 App.java | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100644 App.java

diff --git a/App.java b/App.java
new file mode 100644
index 0000000..33e4924
--- /dev/null
+++ b/App.java
@@ -0,0 +1,196 @@
+//package com.madrakrystian.algebra;
+
+import java.util.InputMismatchException;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class App {
+
+// napisać algorytm, który dla danego n ∈ ℕ znajdzie wszystkie:
+//
+//	  elementy odwracalne
+//	  dzielniki zera
+//	  elementy nilpotentne
+//	  elementy idempotentne
+// w pierścieniu {ℤ/nℤ, +, ⋅}.
+	
+//	Przykłady:
+//
+//	    Input: 4
+//	    Output: [[1,3], [0,2], [0,2], [0,1]]
+//
+//	    Input: 6
+//	    Output: [[1,5], [0,2,3,4], [0], [0,1,3,4]]
+
+	
+	// czytanie inputu z System.in
+	static Scanner reader = new Scanner(System.in);  
+	
+	public static void main(String[] args) {
+		
+		// ograniczenie 1000 (!)
+		int number = 1;
+		
+		do{
+			System.out.println("Enter a number (must be 0<a<=1000): ");
+			try {
+	
+				// wpisz liczbe
+				number = reader.nextInt();
+			
+			}catch(InputMismatchException exception) {
+				
+				System.out.println("Integers only, please");
+				reader.nextLine();
+			}
+		}while(number > 1000 || number < 0);
+		
+		// nasza liczba
+		System.out.println("Input: " + number);
+		
+		/* for debug
+		System.out.println("1. Reversible numbers: " + reversible(number));
+		
+		System.out.println("2. Zero divisors: " + zeroDivisors(number));
+		
+		System.out.println("3. Nilpotent numbers: " + nilpotent(number));
+		
+		System.out.println("4. Idempotent numbers: " + idempotent(number));
+		*/
+	
+		// na potrzeby tworzenia programu potrzebna byla jakas dynamiczna struktura danych, po zrobieniu mozna zamienic w tablice
+		Stack<Stack<Integer>> output = new Stack<Stack<Integer>>();
+		
+		// dodanie stosow do nadstosu (dla duzych liczb output staje sie nieczytelny - polecam odkomentowac "for debug")
+		output.push(reversible(number));
+		output.push(zeroDivisors(number));
+		output.push(nilpotent(number));
+		output.push(idempotent(number));
+		
+		// output taki jak w specyfikacji
+		System.out.println("Output: " + output);
+		
+		// zamkniecie reader'a
+		reader.close();
+	}
+	
+	// algorytm nwd (pomocnicza funkcja)
+	public static int nwd(int a, int b) {
+		
+		while(a != b) {
+			if (a < b) {
+				b -= a;
+			}
+			else a -=b;
+		}
+		return a;
+	}
+
+	// 1. elementy odwracalne
+	public static Stack<Integer> reversible(int number) {
+		
+		Stack<Integer> reversibleNumbers = new Stack<Integer>();
+
+		int temp;
+		
+		for (int i = 1; i<number ; i++) {
+				
+			temp = nwd(number, i);
+		
+			// sprawdzam czy jest wzglednie pierwsza
+			if(temp == 1) {
+				reversibleNumbers.push(i);
+			}
+		}
+		return reversibleNumbers;
+	}
+
+	
+	// 2. dzielniki zera
+	public static Stack<Integer> zeroDivisors(int number) {
+		
+		Stack<Integer> zeroDivisors = new Stack<Integer>();
+		
+		// 0 (element neutralny dodawania) zawsze jest swoim dzielnikiem
+		zeroDivisors.push(0);
+		
+		int temp;
+		
+		for(int i = 1; i<number; i++) {
+			
+			temp = i;
+			
+			for(int j=1; j<number; j++) {
+			
+				// jesli a*b mod n = 0 oraz liczby nie ma jeszcze w stosie
+				if((temp*j)%number == 0 && !zeroDivisors.contains(temp)) {
+					zeroDivisors.push(temp);
+				}
+			}
+		}
+		return zeroDivisors;
+	}
+	
+	
+	// 3. elementy nilpotentne
+	public static Stack<Integer> nilpotent(int number) {
+		
+		Stack<Integer> nilpotentNumbers = new Stack<Integer>();
+		
+		// 0 (element neutralny dodawania) zawsze spelnia warunek nilpotentnosci
+		nilpotentNumbers.push(0);
+		
+		int temp, tempPow;
+		
+		for(int i = 2; i<number; i++) {
+			
+			temp = i;
+			
+			// sprawdzam czy jest wzglednie pierwsza jesli tak to nie jest nilpotentna
+			if(nwd(temp,number) == 1) {
+				continue;
+			}
+			
+			// tymczasowe a^n (tempPow^powCount)
+			tempPow = 1;
+			
+			for(int j=1; j<number; j++) {
+				
+				tempPow = (int) Math.pow(temp, j);
+				
+				// warunek sprawdzajacy kandydata na nilpotetna
+				if(tempPow % number == 0) {
+					nilpotentNumbers.push(temp);
+					break;
+				}
+			}
+		}
+		return nilpotentNumbers;
+	}
+	
+	
+	// 4. elementy idempotentne
+	public static Stack<Integer> idempotent(int number) {
+		
+		Stack<Integer> idempotentNumbers = new Stack<Integer>();
+		
+		// 0 (element neutralny dodawania) zawsze spelnia warunek idempotentnosci
+		idempotentNumbers.push(0);
+		
+		int temp;
+		
+		for(int i = 1; i<number; i++) {
+			
+			temp = i;
+		
+			// jesli a^2 mod n == a
+			if(Math.pow(temp, 2) % number == temp) {
+				
+				idempotentNumbers.push(temp);
+			}
+		}
+		return idempotentNumbers;
+	}
+
+}
+
-- 
2.20.1


From 42bc4ae1227779b0a6b7b55196183b0b528df2cb Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Thu, 7 Jun 2018 08:27:00 +0000
Subject: [PATCH 3/5] Zmiana inputu

---
 MainApp.java | 623 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 342 insertions(+), 281 deletions(-)

diff --git a/MainApp.java b/MainApp.java
index 56ab965..90e7664 100644
--- a/MainApp.java
+++ b/MainApp.java
@@ -1,282 +1,343 @@
-//package com.madrakrystian.algebra;
-
-import java.util.Arrays;
-import java.util.Scanner;
-
-public class MainApp {
-
-	
-//	Napisać program, który dla danego pierścienia współczynników R = ℤ/nℤ, n ∈ ℕ oraz wielomianów f,g ∈ R[x] zmiennej x znajdzie:
-//
-//	    iloczyn f⋅g ∈ R[x]
-//	    klasę reszty f ∈ R[x]/(g)
-//	    największy wspólny dzielnik nwd(f,g) korzystając z algorytmu Euklidesa.
-//
-//	Uwaga: wielomiany są podawane jako ciąg współczynników od wyrazu wolnego, do współczynnika wiodącego.
-//
-//	Termin: 07.06
-//	Przykłady:
-//
-//	    Input: 2, [1,1,1,0,1], [0,1,1] (i.e. f = 1 + x + x² + x⁴, g = x² + x)
-//	    Output: [[0,1,0,0,1,1,1], [1,1], [1,1]]
-//
-//	    Input: 6, [2,1,0,2,1,3], [1,0,0,5]
-//	    Output: [[3,1,0,5,0,1,4,5,5], [5,2,1], DivisionError]
-
-
-// Input w programie dla przykladu 1
-//	Podaj n: 
-//		2
-//		Pierwszy wielomian: 
-//		Podaj liczbe wyrazow w wielomianie: 
-//		5
-//		Podaj kolejne wyrazy wielomianu po przycisku enter
-//		1
-//		1
-//		1
-//		0
-//		1
-//		Drugi wielomian: 
-//		Podaj liczbe wyrazow w wielomianie: 
-//		3
-//		Podaj kolejne wyrazy wielomianu po przycisku enter
-//		0
-//		1
-//		1
-	
-	
-	
-	// czytanie inputu z System.in
-	static Scanner reader = new Scanner(System.in);  
-	
-	public static void main(String[] args) {
-		
-		// wielomiany
-		int polyOne[];
-		int polyTwo[];
-
-		// wspolczynnik n
-		int n=1;
-	
-		//input
-		do{
-			System.out.println("Podaj n: ");
-			// wpisz liczbe
-			n = reader.nextInt();
-
-		}while(n > 1000 || n <= 0);
-		
-		
-		System.out.println("Pierwszy wielomian: ");
-		polyOne = fillPolynomial();
-		
-		System.out.println("Drugi wielomian: ");
-		polyTwo = fillPolynomial();
-		
-		// wyswietl wielomiany
-		System.out.println("f:" + Arrays.toString(polyOne));
-		System.out.println("g:" + Arrays.toString(polyTwo));
-		
-		// 1.
-		System.out.println("1. iloczyn f*g: ");
-		int res[] = modTheTab(polynomialsMultiplication(polyOne, polyTwo),n);
-		System.out.println(Arrays.toString(res));
-		
-		// 2.
-		System.out.println("2. klasa reszty: ");
-		res = polynomialsDivide(polyOne,polyTwo,n);
-		System.out.println(Arrays.toString(res));
-		
-		// 3.
-		System.out.println("3. nwd: ");
-		res = nwd(polyOne,polyTwo,n);
-		System.out.println(Arrays.toString(res));
-		
-		reader.close();
-	}
-
-	
-	// uzupelnianie tablicy
-	public static int[] fillPolynomial() {
-		
-		// zmienna pomocnicza 
-		int temp = 0;
-		
-		System.out.println("Podaj liczbe wyrazow w wielomianie: ");
-		temp = reader.nextInt();
-		
-		int[] tab = new int[temp];
-		
-		// uzupelnianie pierwszego wielomianu
-		System.out.println("Podaj kolejne wyrazy wielomianu po przycisku enter");
-
-		for(int i=0; i<tab.length; i++){
-			
-			temp = reader.nextInt();
-			
-			tab[i] = temp;
-		}
-		return tab;
-	}
-	
-	// dzielenie modulo tablicy
-	public static int[] modTheTab(int tab[], int mod) {
-		
-		for(int i=0; i<tab.length; i++) {
-			tab[i] = tab[i] % mod;
-		}
-		return tab;
-	}
-	
-	// 1. mnozenie wielomianow
-	public static int[] polynomialsMultiplication(int polyOne[], int polyTwo[]) {
-		
-		// suma dlugosci
-		int amount = polyOne.length + polyTwo.length;
-		
-		// nowa tablica bedzie dlugosci sumy poteg wyrazow wiodacych obu tablic -1
-		int result[] = new int[amount-1];
-		
-		// wypelnienie nowej tablicy zerami
-		for(int i=0; i<result.length; i++) {
-			result[i] = 0;
-		}
-		// mnozenie
-		for(int i=0; i<polyOne.length; i++) {
-			
-			for(int j=0; j<polyTwo.length; j++) {
-				result[i+j] += polyOne[i] * polyTwo[j];
-			}
-		}
-		return result;
-	}
-	
-	public static int[] polynomialMultiplication(int poly[], int number) {
-		
-		for(int i=0; i<poly.length; i++) {
-			poly[i] *= number;
-		}
-		
-		return poly;
-	}
-	
-	public static int[] polynomialsSubstraction(int polyOne[], int polyTwo[]) {
-		
-		int result[] = Arrays.copyOf(polyOne, polyOne.length);
-		
-		// wypelnienie tablicy zerami
-		for(int i=0; i<result.length; i++) {
-			result[i] = 0;
-		}
-		
-		for(int i=0; i<polyOne.length; i++) {
-			result[i] = polyOne[i] - polyTwo[i];
-		}
-		
-		return result;
-	}
-	
-	public static int multiplier(int lo, int lt, int mod) {
-		
-		for(int i=0; i<mod; i++) {
-		
-			if(lo ==  (lt*i) % mod) {
-				return i;
-			}
-		}
-		
-		// error
-		return -1;
-	}
-
-	public static int[] polynomialShift(int poly[], int places) {
-			
-		// jesli przesunac w lewo o 0 to kopiuj tablice
-		if(places == 0) {
-			int[] res = Arrays.copyOf(poly, poly.length);
-			return res;
-		}
-		// bardzo brzydkie przesuwanie
-		else {
-			int[] res = new int[poly.length];
-			
-			for(int i=0; i<poly.length-places; i++) {
-				res[i] = poly[i+places];
-			}
-			
-			for(int j=poly.length - places + 1; j<res.length; j++) {
-				res[j]=0;
-			}
-			
-			return res;
-		}
-	}
-	
-	//2. Dzielenie wielomianow
-	public static int[] polynomialsDivide(int polyOne[], int polyTwo[], int mod) {
-		
-		// druga tablica ale z rowna liczba indeksow co pierwsza
-		int[] tempTab = new int[polyOne.length];
-		// output
-		int[] result;
-		
-		// wypelnienie tablicy zerami
-		for(int i=0; i<tempTab.length; i++) {
-			tempTab[i] = 0;
-		}
-		
-		// wypelnienie tablicy od konca elementami z konca drugiego wielomianu
-		for(int j=0; j<polyTwo.length; j++) {
-			tempTab[tempTab.length - 1 - j] = polyTwo[polyTwo.length - 1 - j];
-		}
-		
-		// stopnie wielomianow
-		int pod = polyOne.length-1;
-		int ptd = polyTwo.length-1;
-		
-		// liczba przez ktora bedziemy mnozyc tablice
-		int temp,i=0;
-		
-		// dopóki wielomian w ostatnim rzędzie nie będzie stopnia mniejszego niż stopień dzielnika
-		while(pod >= ptd) {
-			
-			// modulo dla ujemnych
-			if(polyOne[pod]<0) {
-				polyOne[pod] = mod + polyOne[pod];
-			}
-			
-			// szukany mnoznik
-			temp =  multiplier(polyOne[pod], polyTwo[ptd], mod);
-			
-			// przesuniecie tablicy
-			tempTab = polynomialShift(tempTab,i);
-			
-			// mnozenie wielomianow
-			tempTab = polynomialMultiplication(tempTab, temp);
-			
-			tempTab = modTheTab(tempTab, mod);
-			
-			// odejmowanie wielomianow
-			polyOne = polynomialsSubstraction(polyOne,tempTab);
-			
-			// zmiejszamy stopien pierwszego wielomianu
-			pod--;
-			
-			// zwiekszamy liczbe przesuniec drugiej tablicy
-			i++;
-			
-		}
-		result = Arrays.copyOf(polyOne, i-1);
-		
-		return result;
-	}
-	
-	// 3.
-	public static int[] nwd(int polyOne[], int polyTwo[], int mod) {
-		if(polyTwo.length == 0) {
-			return polyOne;
-		}
-		return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
-	}
-		
+//package com.madrakrystian.algebra;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class MainApp {
+
+	
+//	Napisać program, który dla danego pierścienia współczynników R = ℤ/nℤ, n ∈ ℕ oraz wielomianów f,g ∈ R[x] zmiennej x znajdzie:
+//
+//	    iloczyn f⋅g ∈ R[x]
+//	    klasę reszty f ∈ R[x]/(g)
+//	    największy wspólny dzielnik nwd(f,g) korzystając z algorytmu Euklidesa.
+//
+//	Uwaga: wielomiany są podawane jako ciąg współczynników od wyrazu wolnego, do współczynnika wiodącego.
+//
+//	Termin: 07.06
+//	Przykłady:
+//
+//	    Input: 2, [1,1,1,0,1], [0,1,1] (i.e. f = 1 + x + x² + x⁴, g = x² + x)
+//	    Output: [[0,1,0,0,1,1,1], [1,1], [1,1]]
+//
+//	    Input: 6, [2,1,0,2,1,3], [1,0,0,5]
+//	    Output: [[3,1,0,5,0,1,4,5,5], [5,2,1], DivisionError]
+	
+		
+	// czytanie inputu z System.in
+	static Scanner reader = new Scanner(System.in);  
+	
+	public static void main(String[] args) {
+		
+		// liczniki indeksow wielomianow
+		int counterFirst = 0, counterSecond = 0;
+		
+		// wielomiany + pomocniczme stosy
+		int polyOne[];
+		Stack<Integer> p1 = new Stack<Integer>();
+		int polyTwo[];
+		Stack<Integer> p2 = new Stack<Integer>();
+
+		// wspolczynnik n
+		int n=1;
+	
+		
+		String str;
+        String input;
+        
+        char temp;
+        
+      	//
+      	// poprawiony bardzo nieelegancki nowy input
+      	//
+      
+		input = reader.nextLine();
+		
+		BufferedReader read = new BufferedReader(
+		  new StringReader(input));
+		         
+		// od poczatku pierwszego wielomianu '['
+		int i = 3;
+		try {
+		  if ((str = read.readLine()) != null) {
+		                 
+		          if (str.length() > 0) {
+		                 n = Character.getNumericValue(str.charAt(0));
+		          }
+		          temp = str.charAt(i);
+		          while(temp != ']') {
+		        	  
+		        	  if(temp != ',') {
+		        	    p1.push(Character.getNumericValue(temp));
+		        	  	counterFirst++;
+		        	  }
+		        	  i++;
+		        	  temp = str.charAt(i);
+		          }
+		          
+		          // przejscie do drugiej tablicy (zakladamy ze wielomiany oddzielone sa spacja)
+		          i += 3;
+		          temp = str.charAt(i);
+		          
+		          while(temp != ']') {
+			   
+		        	  if(temp != ',') {
+			        	    p2.push(Character.getNumericValue(temp));
+			        	  	counterSecond++;
+			        	  }
+			          i++;
+			       	  temp = str.charAt(i);
+			     }
+		          
+		        // inicjalizacja tablic
+		        polyOne = new int[counterFirst];
+		  		polyTwo = new int[counterSecond];
+		  		
+		  		// wypelnianie tablic
+		  		for(int j=polyOne.length-1; j>=0; j--) {
+		  			
+		  			polyOne[j] = p1.pop();
+		  		}
+		  		
+		  		for(int j=polyTwo.length-1; j>=0; j--) {
+		  			polyTwo[j] = p2.pop();
+		  		}
+		  		
+		  		
+				// wyswietl wielomiany
+				System.out.println("f:" + Arrays.toString(polyOne));
+				System.out.println("g:" + Arrays.toString(polyTwo));
+				
+				// 1.
+				System.out.println("1. iloczyn f*g: ");
+				int res[] = modTheTab(polynomialsMultiplication(polyOne, polyTwo),n);
+				System.out.println(Arrays.toString(res));
+				
+				// 2.
+				System.out.println("2. klasa reszty: ");
+				res = polynomialsDivide(polyOne,polyTwo,n);
+				System.out.println(Arrays.toString(res));
+				
+				// 3.
+				System.out.println("3. nwd: ");
+				res = nwd(polyOne,polyTwo,n);
+				System.out.println(Arrays.toString(res));
+				
+				reader.close();
+		   }
+		 
+		} catch(IOException e) {
+		  e.printStackTrace();
+		}
+		
+		//input(old)
+		/*
+		do{
+			System.out.println("Podaj n: ");
+			// wpisz liczbe
+			n = reader.nextInt();
+
+		}while(n > 1000 || n <= 0);
+		
+		
+		System.out.println("Pierwszy wielomian: ");
+		polyOne = fillPolynomial();
+		
+		System.out.println("Drugi wielomian: ");
+		polyTwo = fillPolynomial();
+		*/
+		
+		
+		reader.close();
+	}
+
+	
+	// uzupelnianie tablicy
+	public static int[] fillPolynomial() {
+		
+		// zmienna pomocnicza 
+		int temp = 0;
+		
+		System.out.println("Podaj liczbe wyrazow w wielomianie: ");
+		temp = reader.nextInt();
+		
+		int[] tab = new int[temp];
+		
+		// uzupelnianie pierwszego wielomianu
+		System.out.println("Podaj kolejne wyrazy wielomianu po przycisku enter");
+
+		for(int i=0; i<tab.length; i++){
+			
+			temp = reader.nextInt();
+			
+			tab[i] = temp;
+		}
+		return tab;
+	}
+	
+	
+	// dzielenie modulo tablicy
+	public static int[] modTheTab(int tab[], int mod) {
+		
+		for(int i=0; i<tab.length; i++) {
+			tab[i] = tab[i] % mod;
+		}
+		return tab;
+	}
+	
+	// 1. mnozenie wielomianow
+	public static int[] polynomialsMultiplication(int polyOne[], int polyTwo[]) {
+		
+		// suma dlugosci
+		int amount = polyOne.length + polyTwo.length;
+		
+		// nowa tablica bedzie dlugosci sumy poteg wyrazow wiodacych obu tablic -1
+		int result[] = new int[amount-1];
+		
+		// wypelnienie nowej tablicy zerami
+		for(int i=0; i<result.length; i++) {
+			result[i] = 0;
+		}
+		// mnozenie
+		for(int i=0; i<polyOne.length; i++) {
+			
+			for(int j=0; j<polyTwo.length; j++) {
+				result[i+j] += polyOne[i] * polyTwo[j];
+			}
+		}
+		return result;
+	}
+	
+	public static int[] polynomialMultiplication(int poly[], int number) {
+		
+		for(int i=0; i<poly.length; i++) {
+			poly[i] *= number;
+		}
+		
+		return poly;
+	}
+	
+	public static int[] polynomialsSubstraction(int polyOne[], int polyTwo[]) {
+		
+		int result[] = Arrays.copyOf(polyOne, polyOne.length);
+		
+		// wypelnienie tablicy zerami
+		for(int i=0; i<result.length; i++) {
+			result[i] = 0;
+		}
+		
+		for(int i=0; i<polyOne.length; i++) {
+			result[i] = polyOne[i] - polyTwo[i];
+		}
+		
+		return result;
+	}
+	
+	public static int multiplier(int lo, int lt, int mod) {
+		
+		for(int i=0; i<mod; i++) {
+		
+			if(lo ==  (lt*i) % mod) {
+				return i;
+			}
+		}
+		
+		// error
+		return -1;
+	}
+
+	public static int[] polynomialShift(int poly[], int places) {
+			
+		// jesli przesunac w lewo o 0 to kopiuj tablice
+		if(places == 0) {
+			int[] res = Arrays.copyOf(poly, poly.length);
+			return res;
+		}
+		// bardzo brzydkie przesuwanie
+		else {
+			int[] res = new int[poly.length];
+			
+			for(int i=0; i<poly.length-places; i++) {
+				res[i] = poly[i+places];
+			}
+			
+			for(int j=poly.length - places + 1; j<res.length; j++) {
+				res[j]=0;
+			}
+			
+			return res;
+		}
+	}
+	
+	//2. Dzielenie wielomianow
+	public static int[] polynomialsDivide(int polyOne[], int polyTwo[], int mod) {
+		
+		// druga tablica ale z rowna liczba indeksow co pierwsza
+		int[] tempTab = new int[polyOne.length];
+		// output
+		int[] result;
+		
+		// wypelnienie tablicy zerami
+		for(int i=0; i<tempTab.length; i++) {
+			tempTab[i] = 0;
+		}
+		
+		// wypelnienie tablicy od konca elementami z konca drugiego wielomianu
+		for(int j=0; j<polyTwo.length; j++) {
+			tempTab[tempTab.length - 1 - j] = polyTwo[polyTwo.length - 1 - j];
+		}
+		
+		// stopnie wielomianow
+		int pod = polyOne.length-1;
+		int ptd = polyTwo.length-1;
+		
+		// liczba przez ktora bedziemy mnozyc tablice
+		int temp,i=0;
+		
+		// dopóki wielomian w ostatnim rzędzie nie będzie stopnia mniejszego niż stopień dzielnika
+		while(pod >= ptd) {
+			
+			// modulo dla ujemnych
+			if(polyOne[pod]<0) {
+				polyOne[pod] = mod + polyOne[pod];
+			}
+			
+			// szukany mnoznik
+			temp =  multiplier(polyOne[pod], polyTwo[ptd], mod);
+			
+			// przesuniecie tablicy
+			tempTab = polynomialShift(tempTab,i);
+			
+			// mnozenie wielomianow
+			tempTab = polynomialMultiplication(tempTab, temp);
+			
+			tempTab = modTheTab(tempTab, mod);
+			
+			// odejmowanie wielomianow
+			polyOne = polynomialsSubstraction(polyOne,tempTab);
+			
+			// zmiejszamy stopien pierwszego wielomianu
+			pod--;
+			
+			// zwiekszamy liczbe przesuniec drugiej tablicy
+			i++;
+			
+		}
+		result = Arrays.copyOf(polyOne, i-1);
+		
+		return result;
+	}
+	
+	// 3.
+	public static int[] nwd(int polyOne[], int polyTwo[], int mod) {
+		if(polyTwo.length == 0) {
+			return polyOne;
+		}
+		return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
+	}
+		
 }
\ No newline at end of file
-- 
2.20.1


From 2c6b020848ac78d29f65f7d580ad77436dfcca14 Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Thu, 7 Jun 2018 15:10:43 +0000
Subject: [PATCH 4/5] Plik gotowy do kompilacji

---
 MainApp.java | 46 +++++++++++++++++-----------------------------
 1 file changed, 17 insertions(+), 29 deletions(-)

diff --git a/MainApp.java b/MainApp.java
index 90e7664..da718f8 100644
--- a/MainApp.java
+++ b/MainApp.java
@@ -1,5 +1,3 @@
-//package com.madrakrystian.algebra;
-
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.StringReader;
@@ -8,25 +6,6 @@ import java.util.Scanner;
 import java.util.Stack;
 
 public class MainApp {
-
-	
-//	Napisać program, który dla danego pierścienia współczynników R = ℤ/nℤ, n ∈ ℕ oraz wielomianów f,g ∈ R[x] zmiennej x znajdzie:
-//
-//	    iloczyn f⋅g ∈ R[x]
-//	    klasę reszty f ∈ R[x]/(g)
-//	    największy wspólny dzielnik nwd(f,g) korzystając z algorytmu Euklidesa.
-//
-//	Uwaga: wielomiany są podawane jako ciąg współczynników od wyrazu wolnego, do współczynnika wiodącego.
-//
-//	Termin: 07.06
-//	Przykłady:
-//
-//	    Input: 2, [1,1,1,0,1], [0,1,1] (i.e. f = 1 + x + x² + x⁴, g = x² + x)
-//	    Output: [[0,1,0,0,1,1,1], [1,1], [1,1]]
-//
-//	    Input: 6, [2,1,0,2,1,3], [1,0,0,5]
-//	    Output: [[3,1,0,5,0,1,4,5,5], [5,2,1], DivisionError]
-	
 		
 	// czytanie inputu z System.in
 	static Scanner reader = new Scanner(System.in);  
@@ -51,11 +30,7 @@ public class MainApp {
         
         char temp;
         
-      	//
-      	// poprawiony bardzo nieelegancki nowy input
-      	//
-      
-		input = reader.nextLine();
+		input = args[0];
 		
 		BufferedReader read = new BufferedReader(
 		  new StringReader(input));
@@ -120,7 +95,9 @@ public class MainApp {
 				// 2.
 				System.out.println("2. klasa reszty: ");
 				res = polynomialsDivide(polyOne,polyTwo,n);
-				System.out.println(Arrays.toString(res));
+				if(res != null){
+					System.out.println(Arrays.toString(res));
+				}
 				
 				// 3.
 				System.out.println("3. nwd: ");
@@ -134,7 +111,7 @@ public class MainApp {
 		  e.printStackTrace();
 		}
 		
-		//input(old)
+		//input
 		/*
 		do{
 			System.out.println("Podaj n: ");
@@ -276,6 +253,11 @@ public class MainApp {
 	//2. Dzielenie wielomianow
 	public static int[] polynomialsDivide(int polyOne[], int polyTwo[], int mod) {
 		
+		if(polyOne.length < polyTwo.length) {
+			System.out.println("Division error");
+			return null;
+		}
+		
 		// druga tablica ale z rowna liczba indeksow co pierwsza
 		int[] tempTab = new int[polyOne.length];
 		// output
@@ -334,10 +316,16 @@ public class MainApp {
 	
 	// 3.
 	public static int[] nwd(int polyOne[], int polyTwo[], int mod) {
+		
 		if(polyTwo.length == 0) {
 			return polyOne;
 		}
-		return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
+		if(polyOne.length >= polyTwo.length) {
+			return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
+		}
+		else {
+			return nwd(polyTwo, polynomialsDivide(polyTwo,polyOne,mod),mod);
+		}
 	}
 		
 }
\ No newline at end of file
-- 
2.20.1


From a23ba7238d137f861899258c78ddebf03bfc5211 Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Thu, 7 Jun 2018 15:11:58 +0000
Subject: [PATCH 5/5] Zad02 Konsola

Java MainApp "6 [1,2,3,0,1] [2,3,1,0,0,5]"
---
 MainApp.class | Bin 0 -> 4170 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 MainApp.class

diff --git a/MainApp.class b/MainApp.class
new file mode 100644
index 0000000000000000000000000000000000000000..856e20dbf145648723b38c3edc2fce0a69cf69aa
GIT binary patch
literal 4170
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

literal 0
HcmV?d00001

-- 
2.20.1