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] 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