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

MainApp.java

@@ -0,0 +1,331 @@
+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 {
+		
+	// 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;
+        
+		input = args[0];
+		
+		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);
+				if(res != null){
+					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
+		/*
+		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) {
+		
+		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
+		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;
+		}
+		if(polyOne.length >= polyTwo.length) {
+			return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
+		}
+		else {
+			return nwd(polyTwo, polynomialsDivide(polyTwo,polyOne,mod),mod);
+		}
+	}
+		
+}