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