kalmar/DALGLI0
1
0
Fork 15
Code Issues Pull Requests 2 Releases Wiki Activity

ZAD4 #33

Closed
s426182 wants to merge 18 commits from (deleted):ZAD4 into master
pull from: (deleted):ZAD4
merge into: kalmar:master
Conversation 3 Commits 18 Files Changed 3 -567
5 changed files with 0 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 6a410ccc1c - Show all commits

21
01-Pierścień-Zn.md
View File

@ -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]]`

19
02-Wielomiany.md
View File

@ -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
View File

@ -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
View File

Binary file not shown.

331
MainApp.java
View File

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