Prześlij pliki do ''

Main.java

@@ -1,44 +1,38 @@
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Scanner;
 
 public class Main {
 
     public static void main(String[] args) {
-        int n;
+        int mod = Integer.parseInt(args[0]);
-        if (args.length < 1) {
+        Polynomials poly = new Polynomials(mod);
-            n = -1;
+        ArrayList<Integer> f = new ArrayList<>();
-            Scanner scanner = new Scanner(System.in);
+        ArrayList<Integer> g = new ArrayList<>();
-            while (n < 2) {
-                System.out.print("n = ");
-                n = scanner.nextInt();
-            }
-        } else { n = Integer.parseInt(args[0]); }
 
-        Ring r = new Ring(n);
+        String[] tmpString = args[1].split(",");
+        String[] tmpString2 = args[2].split(",");
 
-        r.wyznaczOdwracalne();
+        for (String s : tmpString){
-        r.wyznaczDzielniki();
+            f.add(Integer.parseInt(s));
-        r.wyznaczNil();
+        }
-        r.wyznaczId();
+        for (String s : tmpString2){
+            g.add(Integer.parseInt(s));
+        }
 
-        System.out.println("elementy odwracalne (" + r.odwracalne.size() + "):");
+        System.out.print("[");
-        for (int i: r.odwracalne) {
+        for (int i : poly.multiply(f, g)){
-            System.out.print(i + ", ");
+            System.out.print(i + " ");
         }
-        System.out.println();
+        System.out.print("], [");
-        System.out.println("dzielniki zera (" + r.dzielniki.size() + "):");
+        for (int i : poly.divModN(f, g)){
-        for (int i: r.dzielniki) {
+            System.out.print(i + " ");
-            System.out.print(i + ", ");
         }
-        System.out.println();
+        System.out.print("], [");
-        System.out.println("elementy nilpotentne (" + r.nilpotentne.size() + "):");
+        for (int i : poly.gcc(f, g)){
-        for (int i: r.nilpotentne) {
+            System.out.print(i + " ");
-            System.out.print(i + ", ");
-        }
-        System.out.println();
-        System.out.println("elementy idempotentne (" + r.idempotentne.size() + "):");
-        for (int i: r.idempotentne) {
-            System.out.print(i + ", ");
         }
+        System.out.print("]");
+
     }
-}
+}

Polynomials.java

@@ -0,0 +1,99 @@
+import java.util.ArrayList;
+
+public class Polynomials {
+    int n;
+
+    public Polynomials(int n) {
+        this.n = n;
+    }
+
+    private ArrayList<Integer> normalize(ArrayList<Integer> w){
+        for (int i = w.size()-1; i >= 0; --i){
+            if (w.get(i).equals(0)) {
+                w.remove(i);
+            }else {
+                return w;
+            }
+        }
+        return w;
+    }
+
+    public ArrayList<Integer> multiply(ArrayList<Integer> f, ArrayList<Integer> g){
+        ArrayList<Integer> result = new ArrayList<>();
+        int tmp;
+
+        for (int i = 0; i < f.size(); ++i){
+            for (int j = 0; j < g.size(); ++j){
+                tmp = f.get(i) * g.get(j);
+                if (i + j < result.size()){
+                    tmp += result.get(i+j);
+                    result.set(i + j, tmp % n);
+                } else {
+                    while ((i + j) >= (result.size())){
+                        result.add(0);
+                    }
+                    result.set(i + j, tmp % n);
+                }
+            }
+        }
+        return normalize(result);
+    }
+
+    private int getZero(int a, int b) throws ArithmeticException{
+        for (int i = 0; i <= n; ++i){
+            if ((a + (-(b * i))) == 0) return i;
+        }
+        throw new ArithmeticException("not reversible");
+    }
+
+    public ArrayList<Integer> multiplyByConst(ArrayList<Integer> f, Integer a){
+        ArrayList<Integer> result = new ArrayList<>();
+        for (Integer i : f){
+            result.add((i * a) % n);
+        }
+        return result;
+    }
+
+    public ArrayList<Integer> subtract(ArrayList<Integer> f, ArrayList<Integer> g){
+        ArrayList<Integer> result = new ArrayList<>();
+        for (int i = 0; i < f.size(); ++i){
+            if (i < g.size()){
+                result.add(Math.floorMod(f.get(i) - g.get(i), n));
+            } else{
+                result.add(f.get(i));
+            }
+        }
+        return result;
+    }
+
+    public ArrayList<Integer> divModN(ArrayList<Integer> f, ArrayList<Integer> g) throws ArithmeticException{
+        ArrayList<Integer> quotient = new ArrayList<>();
+        ArrayList<Integer> remainder = new ArrayList<>(f);
+        ArrayList<Integer> tmpList;
+        int a = f.size() - 1;
+        int b = g.size() - 1;
+
+        for (int i = 0; i < a - b + 1; ++i){
+            quotient.add(0);
+        }
+
+        int q = quotient.size()-1;
+        int tmp;
+        while (a >= b) {
+            tmp = getZero(remainder.get(a), g.get(b));
+            quotient.set(q--, tmp);
+            tmpList = multiplyByConst(g, tmp);
+            while(tmpList.size() <= a) tmpList.add(0,0);
+            remainder = subtract(remainder, tmpList);
+            --a;
+        }
+        return normalize(remainder);
+    }
+
+    public ArrayList<Integer> gcc (ArrayList<Integer> f, ArrayList<Integer> g){
+        if (g.size() == 0) return f;
+        if (f.size() > g.size()){
+            return gcc(g, divModN(f, g));
+        } else return gcc(g, divModN(g, f));
+    }
+}