01-Pierścień-Zn.md

@@ -1,21 +0,0 @@
-## Zadanie
-
-Napisać algorytm, który dla danego `n ∈ ℕ` znajdzie wszystkie:
-
-  1. elementy odwracalne
-  2. dzielniki zera
-  3. elementy nilpotentne
-  4. elementy idempotentne
-
-w pierścieniu `{ℤ/nℤ, +, ⋅}`.
-
-Termin: 31.05
-
-### 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]]`
-

02-Wielomiany.md

@@ -1,19 +0,0 @@
-## Zadanie
-
-Napisać program, który dla danego pierścienia współczynników `R = ℤ/nℤ, n ∈ ℕ` oraz wielomianów `f,g ∈ R[x] ` zmiennej `x `  znajdzie:
-
-1. iloczyn `f⋅g ∈ R[x]`
-2. klasę reszty `f ∈ R[x]/(g)`
-3. 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]`

Main.java

@@ -0,0 +1,383 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Main {
+	
+	public static void main(String[] args) {
+		
+		String input = args[0];
+		
+		String[] parts = input.split(" ");
+		
+		// n
+		int mod = Integer.parseInt(parts[0]);
+		//int number = Character.getNumericValue(numberStr.charAt(0));
+		
+		String polynomialStr = parts[1];
+		
+		// usuwam '[', ']'
+		polynomialStr = polynomialStr.substring(1, polynomialStr.length()-1);
+		
+		// ,
+		String[] polynomialNumbers = polynomialStr.split(",");
+		
+		LinkedList<Integer> polynomial = new LinkedList<Integer>();
+		
+		// wypelnienie wielomianu
+		polynomial = fill(polynomialNumbers, polynomial);
+		
+		// candidates
+		LinkedList<LinkedList<Integer>> elements = new LinkedList<LinkedList<Integer>>();
+		elements = createCandidates(polynomial,mod);
+		
+		// output
+		// odwracalne
+		System.out.println(reversible(elements,polynomial,mod));
+		// dzielniki zera
+		System.out.println(zeroDivisors(elements,polynomial,mod));
+		// nilpotenty
+		System.out.println(nilpotent(elements,polynomial,mod));
+		// idempotenty
+		System.out.println(idempotent(elements,polynomial,mod));
+	}
+
+	// wypelnienie wielomianu
+	public static LinkedList<Integer> fill(String[] str, LinkedList<Integer> polynomial){
+		
+		for(int i=0; i <str.length; i++) {
+			polynomial.add(Integer.parseInt(str[i]));
+		}
+		
+		return polynomial;
+	}
+	
+	
+	public static void showPoly(LinkedList<Integer> poly) {
+		System.out.println(poly.toString());
+	}
+
+
+	public static int multiplier(int number, int expect, int mod) {
+		
+		/*
+		if(nwd(number,mod) != 1 || nwd(number,mod) != number) {
+			System.out.println("NIE DA SIE");
+			return 0;
+		}*/
+
+		for(int i=1;i<mod;i++) {
+			if(((number*i) % mod) == expect) {
+				return i;
+			}
+		}
+		return 0;
+	}
+
+
+	public static LinkedList<Integer> modPolynomial(int mod, LinkedList<Integer> polynomial){
+		
+		LinkedList<Integer> result = new LinkedList<Integer>();
+		
+		while(!polynomial.isEmpty()) {
+			
+			if(polynomial.peek() < 0) {
+				
+				result.add(mod + polynomial.poll());
+			}
+			else result.add(polynomial.poll() % mod);
+		}
+		return result;
+	}
+	
+	public static LinkedList<Integer> multiplyPolynomial(LinkedList<Integer> p1, int multiplier){
+		
+		LinkedList<Integer> result = new LinkedList<Integer>();
+		
+		while(!p1.isEmpty()) {
+			result.add(p1.poll() * multiplier);
+		}
+		
+		return result;
+	}
+
+	public static LinkedList<Integer> shiftList(LinkedList<Integer> p, int places){
+		
+		LinkedList<Integer> result = new LinkedList<Integer>(p);
+		
+		if(places == 0) {
+			return result;
+		}
+		
+		for(; places>0; places--) {
+			result.addFirst(0);
+		}
+		return result;
+	}
+
+
+	public static LinkedList<Integer> polynomialsMultiplication(LinkedList<Integer> p1, LinkedList<Integer> p2){
+		
+		// suma dlugosci
+		int amount = p1.size() + p2.size();
+		
+		// nowy wielomian bedzie dlugosci sumy poteg wyrazow wiodacych obu tablic -1
+		LinkedList<Integer> result = new LinkedList<Integer>();
+		
+		for(int i=0;i<amount-1;i++) {
+			result.add(0);
+		}
+		
+		// mnozenie
+		for(int i=0; i<p1.size(); i++) {
+			
+			for(int j=0; j<p2.size(); j++) {
+				result.set(i+j, (result.get(i+j) + p1.get(i) * p2.get(j)));
+			}
+		}
+		return result;
+	
+	}
+
+        public static LinkedList<Integer> substractPolynomials(LinkedList<Integer> p1, LinkedList<Integer> p2){
+		
+	        LinkedList<Integer> result = new LinkedList<Integer>();
+		LinkedList<Integer> p2Copy = new LinkedList<Integer>();
+		
+		
+		for(int i=0; i<p2.size(); i++) {
+			p2Copy.add(p2.get(i));
+		}
+		
+		while(!p2Copy.isEmpty()) {
+			result.add(p1.poll() - p2Copy.poll());
+		}
+		
+		while(!p1.isEmpty()) {
+			result.add(p1.poll());
+		}
+		
+		while(result.getLast() == 0) {
+			if(result.size()>1) {
+				result.removeLast();
+			}
+			else break;
+		}
+		
+		return result;
+	}
+
+        public static LinkedList<LinkedList<Integer>> createCandidates(LinkedList<Integer> orig, int mod){
+              LinkedList<LinkedList<Integer>> elements = new LinkedList<LinkedList<Integer>>();
+              LinkedList<Integer> result = new LinkedList<>();
+              result.add(0);
+              int i = 0;
+ 
+              while (result.size() < orig.size()){
+ 
+                  elements.add(new LinkedList<>(result));
+                  i = (i + 1) % mod;
+                  result.set(0, i);
+                  if (i == 0){
+                      if (result.size() == 1){
+                          result.add(1);
+                      }else {
+                          int tmp = (result.get(1) + 1);
+                          result.set(1, tmp);
+  
+                          for (int k = 1; k < result.size(); ++k){
+                              if (result.get(k) == 0 || result.get(k) % mod != 0) break;
+                              tmp = (result.get(k)) % mod;
+                              result.set(k, 0);
+                              if (tmp == 0){
+                                  if (k + 1 < result.size()){
+                                      tmp = (result.get(k + 1) + 1);
+                                      result.set(k + 1, tmp);
+                                  } else {
+                                      result.add(1);
+                                  }
+                              }
+                          }
+                      }
+                  }
+              }
+              return elements;
+        }
+
+	public static LinkedList<Integer> dividePolynomials(LinkedList<Integer> p1, LinkedList<Integer> p2, int mod) {
+		
+		LinkedList<Integer> result = new LinkedList<Integer>(p1);
+		LinkedList<Integer> tmpP = new LinkedList<Integer>();
+		
+		int stP1 = p1.size();
+		int stP2 = p2.size();
+		
+		if(p1.size() < p2.size()) {
+			System.out.println("NIE DA SIE");
+			return result;
+		}
+		
+		int tmp;
+		
+		// sprawdzenie czy reszta jest mniejszego stopnia
+		while(stP1 >= stP2) {
+			
+			tmp = multiplier(p2.getLast(), result.getLast(), mod);
+
+			// przesuniecie
+			tmpP = shiftList(p2,stP1 - stP2);
+			
+			
+			if(tmp != 0) {
+				// mnoznie przez liczbe
+				tmpP = multiplyPolynomial(tmpP,tmp);
+			}
+			
+			// dzielenie modulo
+			tmpP = modPolynomial(mod,tmpP);
+			
+			// odejmowanie 
+			result = substractPolynomials(result,tmpP);
+			
+			result = modPolynomial(mod, result);
+			
+			// st po odjeciu
+			stP1 = result.size();
+			
+		}
+		return result;
+	}
+
+	public static LinkedList<LinkedList<Integer>> idempotent(LinkedList<LinkedList<Integer>> elements, LinkedList<Integer> expect, int mod) {
+		
+		LinkedList<LinkedList<Integer>> result = new LinkedList<LinkedList<Integer>>();
+		LinkedList<Integer> temp = new LinkedList<Integer>();
+		
+		result.add(elements.get(0));
+		
+		for(int i=1; i<elements.size();i++) {
+			// a*a
+			temp = polynomialsMultiplication(elements.get(i),elements.get(i));
+			
+			// mod
+			temp = modPolynomial(mod,temp);
+			
+			if(expect.size()<= temp.size()) {
+				temp = dividePolynomials(temp,expect,mod);
+			}
+			
+			if(temp.equals(elements.get(i))) {
+				result.add(temp);
+			}
+		}
+		
+		return result;
+	}
+
+	
+	public static LinkedList<LinkedList<Integer>> nilpotent(LinkedList<LinkedList<Integer>> elements,LinkedList<Integer> expect, int mod) {
+		
+		LinkedList<LinkedList<Integer>> result = new LinkedList<LinkedList<Integer>>();
+		LinkedList<Integer> temp = new LinkedList<Integer>();
+		
+		LinkedList<Integer> tempPow = new LinkedList<Integer>();
+		
+		result.add(elements.get(0));
+		
+		for(int i=1; i<elements.size();i++) {
+			
+			temp = elements.get(i);
+			
+			for(int j=2; j<mod; j++)
+				
+				tempPow = temp;
+				
+				temp = polynomialsMultiplication(tempPow,temp);
+			
+				// mod
+				temp = modPolynomial(mod,temp);
+			
+				if(temp.size() >= expect.size()) {
+					temp = dividePolynomials(temp, expect, mod);
+				}
+				else continue;
+				
+				if(temp.size() == 1 && temp.getFirst() == 0) {
+					result.add(elements.get(i));
+				}
+		}
+		return result;
+		
+	}
+
+	public static LinkedList<LinkedList<Integer>> reversible(LinkedList<LinkedList<Integer>> elements,LinkedList<Integer> expect, int mod) {
+		
+		LinkedList<LinkedList<Integer>> result = new LinkedList<LinkedList<Integer>>();
+		LinkedList<Integer> temp = new LinkedList<Integer>();
+		
+		for(int i=1; i<mod; i++) {
+			result.add(elements.get(i));
+		}
+		
+		for(int i=mod; i<elements.size();i++) {
+			
+			temp = elements.get(i);
+			
+			if(temp.size() <= expect.size()) {
+				temp = nwdPoly(temp, expect, mod);
+			}
+			
+			if(temp.size() == 1 && temp.getFirst() == 1) {
+				result.add(elements.get(i));
+				continue;
+			}
+		}
+		
+		return result;
+	}
+
+	
+	public static LinkedList<Integer> nwdPoly(LinkedList<Integer> p1, LinkedList<Integer> orig, int mod) {
+		
+		LinkedList<Integer> temp = new LinkedList<Integer>(p1);
+		
+		while(p1.size()>1) {
+			if(p1.size() <= orig.size()) {
+				temp = dividePolynomials(orig,p1,mod);
+				orig = p1;
+				p1 = temp;
+			}
+			
+		}
+		return p1;
+	}	
+
+
+	public static LinkedList<LinkedList<Integer>> zeroDivisors(LinkedList<LinkedList<Integer>> elements,LinkedList<Integer> expect, int mod) {
+		
+		LinkedList<LinkedList<Integer>> result = new LinkedList<LinkedList<Integer>>();
+		LinkedList<Integer> temp = new LinkedList<Integer>();
+		LinkedList<Integer> tempSec = new LinkedList<Integer>();
+		LinkedList<Integer> pfinal = new LinkedList<Integer>();
+	
+		result.add(elements.get(0));
+		
+		for(int i=1; i<elements.size();i++) {
+			
+			temp = elements.get(i);
+			
+			for(int j=1; j<elements.size(); j++) {
+				
+				tempSec = elements.get(j);
+				
+				pfinal = polynomialsMultiplication(temp,tempSec);
+				pfinal = modPolynomial(mod,pfinal);
+				
+				if(pfinal.equals(expect)) {
+					result.add(temp);
+				}
+			}
+		}
+		
+		return result;
+	}	
+}