Usuário(a):Hamaranto/botnum

Não edite diretamente esta página, a não ser para adicionar trechos de código importantes. Se for o caso de alguma modificação (e já adianto, o programa está raw) faça um comentário na discussão. O código a seguir está licenciado para domínio público.

z.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class z extends JApplet
{
	JTextField cnum = new JTextField(10);
	JButton okb = new JButton("OK");
	JTextArea areasaida = new JTextArea(16,30);
	ActionListener a = new ActionListener()
	{
		public void actionPerformed(ActionEvent e)
		{
			String numstring = cnum.getText();
			Integer n = new Integer(0);
			try
			{
				n = Integer.valueOf(numstring, 10);
				botnum t = new botnum(n.intValue());
				botnum ta = new botnum(n.intValue() - 1);
				botnum tp = new botnum(n.intValue() + 1);
				String saida = "";
				saida += "{| border=\"0\" align=\"right\" cellspacing=\"0\" cellpadding=\"4\" style=\"border-width: 1px; border-color: #888888; border-style: solid\"";
				saida += "\n|-----";
				saida += "\n| colspan=\"3\" bgcolor=\"#C0C0FF\" align=\"center\" | <font size=+2>'''" + t.getn() + "'''</font>";
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" | [[Cardinal]]";
				saida += "\n| bgcolor=\"#F0F0FF\" | " + t.extenso();
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" | [[Ordinal]]";
				saida += "\n| bgcolor=\"#F0F0FF\" | " + t.ordinal();
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" | [[Factorização]]";
				saida += "\n| bgcolor=\"#F0F0FF\" | " + t.getn() + " = ";
				int[] fat = t.fatores();
				int c;
				for(c = 0; c < fat.length; c++)
				{
					if(c != fat.length - 1) saida += fat[c] + " x ";
					else saida += fat[c];
				};
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" | [[Numeração romana]]";
				saida += "\n| bgcolor=\"#F0F0FF\" | " + t.romano();
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" | [[Sistema binário]]";
				saida += "\n| bgcolor=\"#F0F0FF\" | " + t.binario();
				saida += "\n|-----";
				saida += "\n| colspan=\"2\" bgcolor=\"#F0F0FF\" style=\"padding: 2px; border-bottom-style: solid; border-width: 1px; border-color: #888888\" | [[Sistema hexadecimal]]";
				saida += "\n| bgcolor=\"#F0F0FF\" style=\"padding: 2px; border-bottom-style: solid; border-width: 1px; border-color: #888888\" | 2A";
				saida += "\n|-----";
				saida += "\n| colspan=\"3\" bgcolor=\"#FFD0D0\" align=\"center\" | '''Propriedades matemáticas'''";
				saida += "\n|-----";
				saida += "\n| bgcolor=\"#FFF0F0\" | [[Função phi de Euler|φ(" + t.getn() + ")]] = " + t.totiente();
				saida += "\n| bgcolor=\"#FFF0F0\" | τ(" + t.getn() + ") = " + t.sigma(0);
				saida += "\n| bgcolor=\"#FFF0F0\" | σ(" + t.getn() + ") = " + t.sigma(1);
				saida += "\n|-----";
				saida += "\n| bgcolor=\"#FFF0F0\" | π(" + t.getn() + ") = " + t.pi();
				saida += "\n| bgcolor=\"#FFF0F0\" | [[Função de Möbius|μ(" + t.getn() + ")]] = " + t.mobius();
				saida += "\n| bgcolor=\"#FFF0F0\" | [[Função de Mertens|''M''(" + t.getn() + ")]] = " + t.mertens();
				saida += "\n|}";
				
				saida += "\n\n'''" + t.getn() + "''' (" + t.extenso() + ", " + t.romano() + ") é um [[número natural]]. ";
				saida += "Ele é precedido pelo [[" + ta.extenso() + "|" + ta.getn() + "]] e sucedido pelo [[" + tp.extenso() + "|" + tp.getn() + "]]";
				
				saida += "\n\n<!--Categoria-->\n[[Categoria:Inteiros]]";
				saida += "\n\n<!--Interwiki-->\n[[en:" + t.getn() + " (number)]]";
				
				areasaida.setText(saida);
			}
			catch(NumberFormatException nfe) {
				areasaida.setText("Por favor, indique um número entre 0 e 999...");
			};
		}
	};
	
	public void init()
	{
		Container apc = getContentPane();
		apc.setLayout(new FlowLayout());
		okb.addActionListener(a);
		apc.add(cnum);
		apc.add(okb);
		areasaida.setLineWrap(true);
		apc.add(areasaida);
		
	}
	
	public static void main(String args[])
	{
		JApplet zap = new z();
		JFrame frame = new JFrame("z");
		frame.getContentPane().add(zap);
		frame.setSize(400,300);
		frame.setVisible(true);
	}
}

botnum.java

/**
* Classe para geracao de texto formatado padrao TikiWiki, relativo a numeros 
* inteiros de 0 a 1024.
*/

import java.lang.*;
import java.util.*;

public class botnum
{
	int n; //@- o número
	String extenso; //@- por extenso
	String ord;
	int difdiv; //@- indica a diferença entre a soma dos divisores e o numero
	
	public botnum(int fn)
	{
		if(fn < 0) fn *= -1;
		if(fn > 999) fn = 0;
		
		n = fn;
	}
	
	public int getn()
	{
		return n;
	}
	
	String extenso()
	{
		extenso = "";
		String unidades_extenso[] = { "zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis", "dezessete", "dezoito", "dezenove" };
		String dezenas_extenso[] = {"", "dez", "vinte", "trinta", "quarenta", "cinqüenta", "sessenta", "setenta", "oitenta", "noventa" };
		String centenas_extenso[] = { "", "cento", "duzentos", "trezentos", "quatrocentos", "quinhentos", "seiscentos", "setecentos", "oitocentos", "novecentos" };

		int u, d, c; //unidade, dezena e centena
		
		if(n <= 19)
		{
			u = n;
			extenso = unidades_extenso[u];
		}
		else if(n <= 99)
		{
			u = n % 10;
			d = (int) Math.floor(n / 10);
			if(u == 0)
			{
				extenso = dezenas_extenso[d];
			}
			else
			{
				extenso = dezenas_extenso[d] + " e " + unidades_extenso[u];
			}
		}
		else if(n <= 999)
		{
			u = n % 10;
			//983 - 900 = 83
			d = (int) Math.floor(n - Math.floor(n / 100) * 100) / 10;
			c = (int) Math.floor(n / 100);
			if(u == 0)
			{
				if(d == 0)
				{
					extenso = centenas_extenso[c];
				}
				else
				{
					extenso = centenas_extenso[c] + " e " + dezenas_extenso[d];
				}
			}
			else if(d == 0)
			{
				extenso = centenas_extenso[c] + " e " + unidades_extenso[u];
			}
			else
			{
				extenso = centenas_extenso[c] + " e " + dezenas_extenso[d] + " e " + unidades_extenso[u];
			}
		}
		else extenso = "";

		/* Caso especial: 100 (para evitar confusao com "cento"). */
		if(n == 100) extenso = "cem"; 

		return extenso;
	}
	
	String ordinal()
	{
		ord = "";
		String[] unidades_ordinal = { "", "primeiro", "segundo", "terceiro", 
		 "quarto", "quinto", "sexto", "sétimo", "oitavo", "nono" };
		String[] dezenas_ordinal = { "", "décimo", "vigésimo", "trigésimo", "quadragésimo", "quintuagésimo", "sexagésimo", "septuagésimo", "octogésimo", "nonagésimo" };
		String[] centenas_ordinal = { "", "centésimo", "ducentésimo", "trecentésimo", "quadringentésimo", "qüingencentésimo", "sexcentésimo", "septingentésimo", "octingentésimo", "noningentésimo" };

		int u, d, c, m;
	
		// x E [0,9] ?
		if(n < 10)
		{
			u = n;
			ord = unidades_ordinal[u];
		}
		// x E [10,99] ?
		else if(n < 100)
		{
			d = (int) Math.floor(n / 10);
			u = n - (d * 10);
			if(u == 0) ord = dezenas_ordinal[d];
			else ord = dezenas_ordinal[d] + " " + unidades_ordinal[u];
		}
		else
		{
			c = (int) Math.floor(n / 100);
			d = (int) Math.floor((n - c * 100) / 10);
			u = n - (c * 100) - (d * 10);
			if(u == 0)
			{
				if(d == 0) ord = centenas_ordinal[c];
				else ord = centenas_ordinal[c] + " " + dezenas_ordinal[d];
			}
			else if(d == 0)
			{
				ord = centenas_ordinal[c] + " " + unidades_ordinal[u];
			}
			else ord = centenas_ordinal[c] + " " + dezenas_ordinal[d] + " " + unidades_ordinal[u];
		}
	
		return ord;
	}


	public boolean verifica_primo()
	{
		boolean primo = true;
		int c1, c2, ndiv2;
		ndiv2 = (int) n / 2 + 1;

		if(n == 1)
		{
			return false;
		}
		else if(n == 2 || n == 3)
		{
			return true;
		}
		else
		{
			// Faz um teste com todos as multiplicacoes possiveis entre 1 e n / 2 (arredondado para o inteiro seguinte).
			for(c1 = 1; c1 <= ndiv2; c1++)
			{
				for(c2 = 1; c2 <= ndiv2 + 1; c2++)
				{
					if((c1 * c2) == n) primo = false;
				}
			}
			return primo;
		}
	}

	public int[] divisores()
	{
		int[] temp = new int[100];
		int[] r;
		int div_atual;
		int c = 0;
		for(div_atual = 1; div_atual < (n/2 + 1); div_atual++)
		{
			if ((n % div_atual) == 0)
			{
				temp[c] = div_atual;
				c++;
			}
		}
		temp[c] = n;
		r = new int[c+1];
		for(int trans = 0; trans <= c; trans++) r[trans] = temp[trans];
		return r;
	}
	
	public int[] fatores()
	{
		int divisor = 2; // Começa com o 2.
		int[] temp = new int[100];
		int[] r;
		int quociente = n;
		int c = 0;

		do
		{
			if((quociente % divisor) == 0)
			{
				quociente /= divisor;
				temp[c] = divisor;
				c++;
			}
			else
			{
				divisor++;
			}
		} while(quociente != 1);
		r = new int[c];
		for(int trans = 0; trans < c; trans++) r[trans] = temp[trans];
		return r;
	}
	
	public boolean verifica_perfeito()
	{
		int[] div = divisores();
		int soma = 0;
		int c = 0;
		for(c = 0; c < div.length; c++)
		{
			soma += div[c];
		}
		soma = soma - n; // Retira o próprio n e soma 1, não contado
		if((soma - n) == 0) return true;
		else return false;
	}
	
	public int totiente ()
	{
		int c, t = 0;
		if(n <= 1) return 0;
		else if(n == 2) return 1;
		else
		{
			for(c = 1; c < n; c++)
			{
				if(mdc(c) == 1) t++;
			}
		}
		return t;
	}

	public int mdc(int n2)
	{
		int a, b, q, r;
	
		// Se alguns dos numeros for igual a 0, returna -1 (nao existe mdc).
		if((n == 0) || (n2 == 0)) return -1;
	
		// Verifica se foi passado numero positivo.
		if(n2 < 0) n2 = -1 * n2;
	
		// a deve ser <= b
		if(n <= n2)
		{
			a = n;
			b = n2;
		}
		else
		{
			a = n2;
			b = n;
		}
	
		q = b / a;
	
		do
		{
			r = b - a * q;
		
			if(r != 0)
			{
				if(r > a)
				{
					q = (r / a);
					b = r;
				}
				else
				{
					q = (a / r);
					b = a;
					a = r;
				}
			}
		} while(r != 0);
		return a;
	}

	public int mobius()
	{
		int[] f;
		int c;
		int anterior = 0;

		// Obtem os fatores do numero.
		f = fatores();

		if(f.length == 1) return -1; //Para primos, mobius = -1.

		// Percorre os fatores, tentando encontrar algum quadrado
		// (ou seja, um fator que se repita).

		for(c = 0; c < f.length; c++)
		{
			if(f[c] == anterior) return 0; //encontrou um quadrado
			else
			{
				anterior = f[c];
			}
		}

		// Se chegou ateh aqui, eh porque nao existe divisor quadrado.
		// Verifica entao se eh decomposto em uma quantidade par ou impar
		// de fatores primos.
		if((f.length % 2) == 0) return 1;
		else return -1;
	}
	
	public int mertens()
	{
		int c;
		int mert = 0;
		for(c = 1; c <= n; c++)
		{
			botnum temp = new botnum(c);
			mert += temp.mobius();
		}
		return mert;
	}
	
	public int pi()
	{
		int c, p = 0;
		if(n == 1) return 1;
		else
		{
			for(c = 1; c <= n; c++)
			{
				botnum ptemp = new botnum(c);
				if(ptemp.verifica_primo())
				{
					p++;
				}
			}
		}
		return p;
	}
	
	public int sigma(int k)
	{
		int[] d;
		int c;
		int soma = 0;
	
		// Obtem os divisores.
		d = divisores();
	
		if(d.length == 1)
		{
			if(k == 0) return 2;
			else return (int) (Math.pow((double) n, (double) k) + 1);
		}
	
		for(c = 0; c < d.length; c++)
		{
			soma += (int) Math.pow((double) d[c], (double) k);
		}
		
		return soma;
	}
	
	public String binario()
	{
		StringBuffer r = new StringBuffer("");
		char[] algarismos = { '0', '1' }; 
		int div = n;
		int vo;
		int resto;
		
		do
		{
			vo = div;
			div = (int) Math.floor(div / 2);
			resto = vo - (div * 2);
			r.append(algarismos[resto]);
		} while(div > 0);
		r.reverse();
		return r.toString();
	}
			
	public String octal()
	{
		StringBuffer r = new StringBuffer("");
		char[] algarismos = { '0', '1', '2', '3', '4', '5', '6', '7' }; 
		int div = n;
		int vo;
		int resto;
		
		do
		{
			vo = div;
			div = (int) Math.floor(div / 8);
			resto = vo - (div * 8);
			r.append(algarismos[resto]);
		} while(div > 0);
		r.reverse();
		return r.toString();
	}

	public String hexadecimal()
	{
		StringBuffer r = new StringBuffer("");
		char[] algarismos = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; 
		int div = n;
		int vo;
		int resto;
		
		do
		{
			vo = div;
			div = (int) Math.floor(div / 16);
			resto = vo - (div * 16);
			r.append(algarismos[resto]);
		} while(div > 0);
		r.reverse();
		return r.toString();
	}

	public String romano()
	{
		String r = "";
		String[] unidades_romano = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX" };
		String[] dezenas_romano = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC" };
		String[] centenas_romano = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM" };
		
		int u, c, d;
	
		if(n < 10)
		{
			u = n;
			r = unidades_romano[u];
		}
		else if(n < 100)
		{
			u = n % 10;
			d = (int) Math.floor(n / 10);
			r = dezenas_romano[d] + unidades_romano[u];
		}
		else
		{ // 982
			u = n % 10;
			c = (int) Math.floor(n / 100);
			d = (int) Math.floor((n - c * 100) / 10);
			r = centenas_romano[c] + dezenas_romano[d] + unidades_romano[u];
		}
		
		return r;
	}
	
}