ZAD4 #33
@ -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]]`
|
||||
|
||||
@ -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]`
|
||||
196
App.java
196
App.java
@ -1,196 +0,0 @@
|
||||
//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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
BIN
MainApp.class
BIN
MainApp.class
Binary file not shown.
331
MainApp.java
331
MainApp.java
@ -1,331 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user