From 9d1452fa164159ab97a849daf40203c64a62ed10 Mon Sep 17 00:00:00 2001
From: Krystian Madra <krymad@st.amu.edu.pl>
Date: Wed, 6 Jun 2018 22:20:32 +0000
Subject: [PATCH] Plik zad01

---
 App.java | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100644 App.java

diff --git a/App.java b/App.java
new file mode 100644
index 0000000..33e4924
--- /dev/null
+++ b/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;
+	}
+
+}
+