import java.awt.*;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.applet.Applet;

class GraphTroj extends java.applet.Applet
{

       int modulo=2;
       int liczby;
       
       public GraphTroj( int mod, int nliczby )
	{
		modulo = mod;
		liczby = nliczby;
	}
               


      /* glowna funkcja rysujaca trojkat */
        public void paint( Graphics g )
        {        
                Rectangle r = getBounds();
                g.clearRect( 0, 0, r.width, r.height );
                g.setColor( Color.black );
                rysujTrojkat( g, modulo);
        }

        void rysujTrojkat( Graphics g, int mod)
        {
                
                /* czesc opisowa */
                Font ft = new Font ( "Tahoma", Font.PLAIN, 12 );
                Font ftb = new Font ( "Tahoma", Font.BOLD, 12 );
                
                g.setFont (ft);
                g.drawString ("Trojkat dla liczb", 30, 20 );

                g.setFont (ftb);
                g.drawString ("F r a k t a l n y c h", 15, 35 );
                
                g.drawLine(15,40,165,40);
        
        g.setFont (ft);
        //g.setColor(new Color(0,128,0));
        g.drawString ("Skala reszt:", 15, 60 );
         g.drawString ("0", 15, 90 );
         g.drawString (new Integer(mod-1).toString(), 140, 90 );
        //g.drawString (" - wieksza reszta ", 15, 70 );

  
                int red = 255;
                int green = 255;
                int blue = 0;
                int kolor;
                int cm = 200;

                int max = 470;
                int x=(int)(max / 2);
                int y=2;
                
                
                if (mod > 6*cm) {
                        cm = 255;
                }
                
                /* tablica gdzie bedziemy wpisywac kolejne liczby */
                int [][] tab = new int [max+1][max+1];
                
                /* warunki brzegowe */
                for (int i=0; i<=max; i++) {
                        tab[i][0] = 0;
                        
                        if (liczby == 4) {
                        	tab[i][0] = 1;
                        }
                        if (i == 0) {
                                tab[0][0] = 1;
                        } else {
                                tab[0][i] = 0;
                        }
                }
                
                if (liczby == 4) {
                	tab[0][0] = 1;
                	
                }
                
                /* rysowanie skali */
                for (int i=0; i<130;i++) {
                
                        kolor = (int)(6*cm/130*i);
                        int a = (int)((i*mod)/130);
                        
                        kolor=(int)(((6*cm)/mod) * a);
                        
                        if (kolor <= cm) {
                                red=cm;
                                green=kolor;
                                blue=0;
                        }else if (kolor <= 2*cm) {
                                      red = cm - (kolor-cm);
                                       green = cm;
                                       blue = 0;
                        }else if (kolor <= 3*cm) {
                                       red = 0;
                                       green = cm;
                                       blue = (kolor - 2*cm);
                        }else if (kolor <= 4*cm) {
                                       red = 0;
                                       green = cm - (kolor - 3*cm);
                                       blue = cm;
                        }else if (kolor <= 5*cm) {
                                       red = (kolor - 4*cm);
                                       green = 0;
                                       blue = cm;
                        }else if (kolor <= 6*cm) {
                                       red = cm;
                                       green = 0;
                                       blue = cm - (kolor - 5*cm);
                        }
                           
                        switch (a) {
                                case 0: red=230;green=230;blue=230;
                                        break;
                        }
                                
                        g.setColor(new Color(red,green,blue));
                        g.drawLine(15+i,65,15+i,75);
                        
                }
                
                /* glowna petla */
                for (int n=1; n<=max; n++) {
                        for (int k=1; k<=n; k++) {
                                
                                
                                /* WZORY REKURENCYJNE */
                                if (n == 1 && k == 1) {
                                        tab[1][1] = 1;
                                        
                                } else {
                                	
					/* LICZBY */
					if (liczby == 1) {
						tab[n][k] = (tab[n-1][k-1] + tab[n-1][k]) % mod;
					}
					if (liczby == 2) {
						tab[n][k] = (tab[n-1][k-1] + (n-1)*tab[n-1][k]) % mod;
					}
					if (liczby == 3) {
						tab[n][k] = (tab[n-1][k-1] + k*tab[n-1][k]) % mod;
					}
					if (liczby == 6) {
						tab[n][k] = (tab[n-1][k-1] + tab[n-1][k]*tab[n-1][k]) % mod;
					}
					if (liczby == 7) {
						tab[n][k] = (tab[n-1][k-1]*tab[n-1][k-1] + tab[n-1][k]) % mod;
					}
					if (liczby == 8) {
						tab[n][k] = (tab[n-1][k-1]*tab[n-1][k-1] + tab[n-1][k]*tab[n-1][k]) % mod;
					}
					if (liczby == 9) {
						tab[n][k] = ((n-1)*tab[n-1][k-1] + (k+1)*tab[n-1][k]) % mod;
					}
					if (liczby == 0) {
						tab[n][k] = ((n+1)*tab[n-1][k-1] + (k-1)*tab[n-1][k]) % mod;
					}
					if (liczby == 4) {
						tab[n][k] = ((n-k)*tab[n-1][k-1] + (k+1)*tab[n-1][k]) % mod;
						
						if (n == k) {
							tab[n][k] = 0;
						}
					}
					if (liczby == 5) {
						tab[n][k] = ((2*n-k-1)*tab[n-1][k-1] + (k+1)*tab[n-1][k]) % mod;
						
						if (n == k) {
							tab[n][k] = 0;
						}
					}
					
					
                                        
                                }
                                
                                /* w zaleznosci od reszty modulo rysujemy punkt danego koloru */
                                
                                kolor=(int)(((6*cm)/mod) * tab[n][k]);
                                
                                if (kolor <= cm) {
                                        red=cm;
                                        green=kolor;
                                        blue=0;
                                }else if (kolor <= 2*cm) {
                                        red = cm - (kolor-cm);
                                        green = cm;
                                        blue = 0;
                                }else if (kolor <= 3*cm) {
                                        red = 0;
                                        green = cm;
                                        blue = (kolor - 2*cm);
                                }else if (kolor <= 4*cm) {
                                        red = 0;
                                        green = cm - (kolor - 3*cm);
                                        blue = cm;
                                }else if (kolor <= 5*cm) {
                                        red = (kolor - 4*cm);
                                        green = 0;
                                        blue = cm;
                                }else if (kolor <= 6*cm) {
                                        red = cm;
                                        green = 0;
                                        blue = (kolor - 5*cm);
                                }
                                
                                
                                switch (tab[n][k]) {
                                        case 0: red=230;green=230;blue=230;
                                                break;                                        
                                }
                                
                                g.setColor(new Color(red,green,blue));
                                
                                /* rysowanie punktu */
                                g.drawLine(x+(k-1)+((int)(n / 2)),y,x+(k-1)+((int)(n / 2)),y);
                        }
                        x--;
                        y++;
                }
    
        }
  
};


public class LiczbyFraktalne extends Applet implements ItemListener
{
        Choice modLista, liczbyLista;
        GraphTroj tablet;
        int modulo=2;
        int liczby=1;
                
        public void init()
        {        
                /* wyswietlanie na ekranie */
                
                tablet = new GraphTroj(modulo,liczby);
		
		liczbyLista = new Choice();
		liczbyLista.addItem("1 - Wspó³czynniki Dwumienne");
		liczbyLista.addItem("2 - Liczby Stirlinga I rodzaju");
		liczbyLista.addItem("3 - Liczby Stirlinga II rodzaju");
		liczbyLista.addItem("4 - Liczby Eulera I rzedu");
		liczbyLista.addItem("5 - Liczby Eulera II rzedu");
		liczbyLista.addItem("6 - Rekurencja 1");
		liczbyLista.addItem("7 - Rekurencja 2");
		liczbyLista.addItem("8 - Rekurencja 3");
		liczbyLista.addItem("9 - Rekurencja 4");
		liczbyLista.addItem("0 - Rekurencja 5");

		
                modLista = new Choice();               
                for (int i=2; i<=1530; i++)
                        modLista.addItem( new Integer(i).toString() );
                
                setLayout( new BorderLayout() );
                                
                Panel sPanel = new Panel();
                sPanel.setLayout( new FlowLayout() );
                sPanel.add( new Label(" Liczby:") );
                sPanel.add( liczbyLista );
                sPanel.add( new Label(" Modulo:") );
		sPanel.add( modLista );
		
		add( "South", sPanel );
		add( "Center", tablet );
		liczbyLista.addItemListener( this );
		modLista.addItemListener( this );
	}
	
	/* czuwanie na zmiane pozycji w liscie */
        public void itemStateChanged( ItemEvent evt )
        {        
                
                if ( evt.getSource() == modLista )
		{
                	String s = evt.getItem().toString();
                	modulo = Integer.parseInt( s );
                }
                if ( evt.getSource() == liczbyLista )
                {
                	String s = evt.getItem().toString();
                	liczby = Integer.parseInt(s.substring(0,1));
                }
                
                remove( tablet );
		tablet = new GraphTroj(modulo,liczby);
		add( "Center", tablet );
		validate();
			
        }        


  
}