DALGLI0/MainApp.java

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