//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;
	}

}