FASOLO

Programação II

Algoritmos / Java

Algoritmo para mostrar apartir de uma frase lida a frase formada pela quantidade de carecteres informados pelo usuário.
================================================================================

import javax.swing.*;
class Exercicio_02
{
public static void main (String args[])
{
int i=0,q=0;
String frase, copia;

frase=JOptionPane.showInputDialog("Digite a frase");
frase=frase + "$";
copia=" ";
q=Integer.parseInt(JOptionPane.showInputDialog("Digite a quantidade de caracteres"));
while ((frase.charAt(i)!= '$') && ( q>0 ))
{
copia=copia + frase.charAt(i);
i ++;
q--;
}
JOptionPane.showMessageDialog(null, copia);
System.exit(0);
}
}

Exercicio para chamar uma método ( funcao ) que eleve um valor qualquer ao quadrado.
===========================================================

import javax.swing.*;
class ValoresLidos
{
public static double ValorDigitado, Resultado ;
public static int i;

public static double FuncaoDobro ( double Valor )
{
return ( Valor * 2 );
}

public static void main (String args [])
{
for ( i=0; i<10; i ++ )
{
ValorDigitado=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor"));
Resultado=FuncaoDobro(ValorDigitado);
JOptionPane.showMessageDialog(null," o valor é : " +z Resultado);
}
System.exit(0);
}
}

Exercicio para chamar uma método ( funcao ) que retorne a média de 3 valores lidos.
=========================================================

import javax.swing.*;
class Media
{
static double V1, V2, V3, Media, Resul;

static double FuncaoMedia ( double Valor1, double Valor2, double Valor3 )
{
Resul=( Valor1 + Valor2 + Valor3 )/3 ;
return Resul;
}

public static void main (String args [])
{
V1=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor1"));
V2=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor2"));
V3=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor3"));
Media=FuncaoMedia(V1, V2, V3);
JOptionPane.showMessageDialog(null," a media é : " + Media);

System.exit(0);
}
}

Exercicio 1 ( dia 21/08/02 - algoritmo exponenciacao )
=====================================

import javax.swing.*;
class Exercicio_2008
{
static double base, exp, resultado;

static double Funcaoexp(double ValorBase, double ValorExp )
{
double resul;
resul=Math.pow(ValorBase,ValorExp);
return resul;
}

public static void main (String args[])
{
base=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor da base "));
exp=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do expoente"));
resultado=Funcaoexp(base,exp );
JOptionPane.showMessageDialog(null, " o resultado é =" + resultado);
System.exit(0);
}
}

Exercicio 2 ( 21/08/02 - Exercicio com procedimento - "VOID" )
============================================

import javax.swing.*;
class Exercicio1_2008
{
static float int1,int2;

public static void ValorMaior( float V1, float V2)
{
if(V1>V2)
{
JOptionPane.showMessageDialog(null, " o primeiro valor é maior : "+V1);
}
else
{
JOptionPane.showMessageDialog(null, " o segundo valor é maior : "+V2);
}

}

public static void main(String args[])
{
int1=Float.parseFloat(JOptionPane.showInputDialog("Digite o primeiro valor"));
int2=Float.parseFloat(JOptionPane.showInputDialog("Digite o primeiro valor"));
ValorMaior(int1,int2);
System.exit(0);
}
}

Algoritmo para chamar um método ( funcao ) que retorne a divisao de v1/v2 caso v1 seja maior ou retorne v1*v2 caso v2 seja o maior valor.
==================================================================================

import javax.swing.*;
class Exercicio_Escolha
{
public static int int1,int2,Resul;

public static int Funcao_Diferenca(int v1, int v2)
{
int Resul;
if(v1>=v2)
{
Resul=v1/v2;
}
else
{
Resul=v1*v2;
}
return Resul;
}

public static void main (String args[])
{
int1=Integer.parseInt(JOptionPane.showInputDialog("Digite o primeiro valor"));
int2=Integer.parseInt(JOptionPane.showInputDialog("Digite o segundo valor"));
Resul=Funcao_Diferenca(int1,int2);
JOptionPane.showMessageDialog(null,"o resultado é "+ Resul);
System.exit(0);
}
}

Programa para colocar em ordem crescente 3 numeros informados, programa resolvido com prodedimento;
========================================================================

import javax.swing.*;
class Exer6_030902
{
public static int v1,v2,v3,n1,n2,n3;
public static String resul,RT;

public static void NumerosCrescentes(int v1,int v2,int v3)
{
if(v1>v2 && v1>v3)
{
n3=v1;
if(v2>v3)
{
n2=v2;
n1=v3;
}
else
{
n2=v3;
n1=v2;
}
}
if(v2>v1 && v2>v3)
{
n3=v2;
if(v1>v3)
{
n2=v1;
n1=v3;
}
else
{
n2=v3;
n1=v1;
}
}
if(v3>v1 && v3>v2)
{
n3=v3;
if(v2>v1)
{
n2=v2;
n1=v1;
}
else
{
n2=v1;
n1=v2;
}
}
JOptionPane.showMessageDialog(null,"a ordem crescente é ="+n1+","+n2+","+n3);
}

public static void main (String args[])
{
v1=Integer.parseInt(JOptionPane.showInputDialog("digite o primeiro valor"));
v2=Integer.parseInt(JOptionPane.showInputDialog("digite o segundo valor"));
v3=Integer.parseInt(JOptionPane.showInputDialog("digite o terceiro valor"));
NumerosCrescentes(v1,v2,v3);
System.exit(0);
}
}

Programa com vetores, informar valor, elevá-lo ao cubo e escrever o valor da nona posicao do vetor cubo.
========================================================================

import javax.swing.*;
class Exercicio1809
{
static int i;
static double valores[]=new double[10];
static double cubo[]=new double[10];
public static void main (String ars[])
{
for (i=0;i<10;i++)
{
valores[i]=Double.parseDouble(JOptionPane.showInputDialog("digite o valor "+i ));
cubo[i]=Math.pow(valores[i],3);
}

JOptionPane.showMessageDialog(null," o valor da 9 posicao é " + cubo[9]);
System.exit(0);
}

}

Exercicio com vetor, definindo o tamanho do vetor dentro do algoritmo principal ( informando o tamanho do vetor )
=============================================================================

import javax.swing.*;
class Exercicio1809A
{
static int i;
static int posicao;
static double[] valores, cubo;
public static void main (String ars[])
{
posicao=Integer.parseInt(JOptionPane.showInputDialog("digite o número de posições"));
valores=new double[posicao];
cubo=new double[posicao];

for (i=0;i<posicao;i++)
{

valores[i]=Double.parseDouble(JOptionPane.showInputDialog("digite o valor "));
cubo[i]=Math.pow(valores[i],3);
}

JOptionPane.showMessageDialog(null," o valor da posicao é " + cubo[posicao-1]);
System.exit(0);
}

}

//Exercicio para ler 2 vetores A e B c/ 20 elementos. Construir
// um terceiro vetor C contendo os valores de A X B
==========================================

import javax.swing.*;
class Exer2de1009
{
static double v1[]=new double[4];
static double v2[]=new double[4];
static double produto[]=new double[4];
static int i;

public static void main (String args[])
{
for(i=0;i<4;i++)
{
v1[i]=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do vetor 1 na posicao "+i));
v2[i]=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do vetor 2 na posicao "+i));
produto[i]=v1[i]*v2[i];
}
JOptionPane.showMessageDialog(null," o valor do 3 vetor na posicao 2 é "+produto[2]);
System.exit(0);
}
}

//Programa para detectar valores positivos inteiros, pares ou impares;
======================================================

import javax.swing.*;
class Exer1e2Pg122
{
public static float V;

//procedimento para escolher se o numero é positivo ou não;
public static void Escolha()
{
if(V>0)
{
JOptionPane.showMessageDialog(null,"Valor Positivo");
}
else
{
JOptionPane.showMessageDialog(null,"Valor não Positivo");
}
}

//procedimento para escolher par ou impar
public static void EscolhaPar()
{
if(V%2==0)
{
JOptionPane.showMessageDialog(null,"Valor Par");
}
else
{
JOptionPane.showMessageDialog(null,"Valor Impar");
}
}

//programa Principal
public static void main (String args[])
{
V=Float.parseFloat(JOptionPane.showInputDialog("Digite o valor"));
Escolha();
EscolhaPar();
System.exit(0);
}
}

//Programa com vetores, informar valor da nona posicao do vetor cubo.

import javax.swing.*;
class Exercicio_1809
{
static int i;
static double posicao;
static double[] valores, cubo=new double[];
public static void main (String ars[])
{
for (i=0;i<10;i++)
{
posicao=Double.parseDouble(JOptionPane.showInputDialog("digite o número de posições"));
valores=new double [posicao];
valores[i]=Double.parseDouble(JOptionPane.showInputDialog("digite o valor "+i ));
cubo[i]=Math.pow(valores[i],3);
}

JOptionPane.showMessageDialog(null," o valor da 9 posicao é " + cubo[9]);
System.exit(0);
}

}

//Exercicio com vetor, definindo o tamanho do vetor dentro do algoritmo principal ( lendo o tamanho )

import javax.swing.*;
class Exercicio_1809A
{
static int i;
static int posicao;
static double[] valores, cubo;
public static void main (String ars[])
{
posicao=Integer.parseInt(JOptionPane.showInputDialog("digite o número de posições"));
valores=new double[posicao];
cubo=new double[posicao];

for (i=0;i<posicao;i++)
{

//Dicionario

import javax.swing.*;
class dicionario
{
public static String palavra="";
public static String tipo="i";
public static String[] palIngles=new String[5];
public static String[] palPort=new String[5];
public static int i;

public static void lerPalavra()
{
for(i=0;i<5;i++)
{
palIngles[i]=JOptionPane.showInputDialog("Digite uma palavra em Inglês");
palPort[i]=JOptionPane.showInputDialog("Digite a tradução em Português");
}
}

public static String traduzirPalavra( String tipo, String palavra)
{
String resul="Palavra não encontrada";

if(tipo.equalsIgnoreCase("i"))
{
for(i=0;i<5;i++)
{
if(palavra.equals(palIngles[i]))
{
resul=palPort[i];
}
}
}
if(tipo.equalsIgnoreCase("p"))
{
for(i=0;i<5;i++)
{
if(palavra.equals(palPort[i]))
{
resul=palIngles[i];
}
}
}
return (resul);
}

public static void main (String args[])
{
lerPalavra();
while(tipo.equalsIgnoreCase("i") || tipo.equalsIgnoreCase("p"))
{
tipo=JOptionPane.showInputDialog("Digite\n\"i\" para traduzir palavra de Inglês para Português \n\"p\" para traduzir palavra do Português para Inglês\nou qualquer outra letra para sair");
if(tipo.equalsIgnoreCase("i") || tipo.equalsIgnoreCase("p"))
{
palavra=JOptionPane.showInputDialog("Digite a palavra a ser traduzida");
palavra=traduzirPalavra(tipo,palavra);
JOptionPane.showMessageDialog(null, "A tradução é : "+ palavra);
}
else
{
System.exit(0);
}
}
}
}

//Trabalho Armazem

import javax.swing.*;
class joniEvandro
{
public static double[][]matriz=new double[3][3];
public static String[]produto=new String[3];
public static String[]armazem=new String[3];
public static double[]custo=new double[3];
public static void lerEstoque()
{
int i,j;

for(i=0;i<3;i++)
{
armazem[i]=JOptionPane.showInputDialog("Informe o nome do armazem "+(i+1));

for(j=0;j<3;j++)
{
matriz[i][j]=Double.parseDouble(JOptionPane.showInputDialog("Digite o estoque do produto "+(j+1)+" no armazem "+(i+1)));
}
}

for(i=0;i<3;i++)
{
produto[i]=JOptionPane.showInputDialog("Digite o nome do "+(i+1)+ " produto ");
custo[i]=Double.parseDouble(JOptionPane.showInputDialog("Digite o custo unitário para o produto "+(i+1)));
}
}

public static void dadosPorArmazem()
{
int i,j;
double tot1=0, tot2=0, tot3=0;

for(i=0;i<4;i++)
{
for(j=0;j<3;j++)
{
if(i==0)
{
tot1=tot1+matriz[i][j];
}
if(i==1)
{
tot2=tot2+matriz[i][j];
}
if(i==2)
{
tot3=tot3+matriz[i][j];
}
}
}
JOptionPane.showMessageDialog(null,"No armazem "+armazem[0]+" estão armazenados "+tot1+" produtos");
JOptionPane.showMessageDialog(null,"No armazem "+armazem[1]+" estão armazenados "+tot2+" produtos");
JOptionPane.showMessageDialog(null,"No armazem "+armazem[2]+" estão armazenados "+tot3+" produtos");
}

public static void maisProduto2()
{
int i,j=1;
double maior=0;
String armaz="";

for(i=0;i<3;i++)
{
if(matriz[i][j]>maior)
{
maior=matriz[i][j];
armaz=armazem[i];
}
}
JOptionPane.showMessageDialog(null,"O armazem que possui maior quantidade de "+produto[1]+ " é "+armaz+" e possui "+maior+" produtos");
}

public static void custoTotalUnitario()
{
int i,j;
double soma=0;

for (i=0; i<3; i++)
{
for (j=0; j<3; j++)
{
soma=soma+matriz[i][j]*custo[j];
JOptionPane.showMessageDialog(null, "O custo total do produto "+ produto[j]+ " no armazem de "+armazem[i]+ " é "+soma);
soma=0;
}
}
}

public static void custoTotalPorArmazem()
{
int i,j;
double soma=0;

for (i=0; i<3; i++)
{
for (j=0; j<3; j++)
{
soma=soma+matriz[i][j]*custo[j];
}
JOptionPane.showMessageDialog(null, "O custo total por em "+armazem[i]+" é "+soma);
soma=0;
}
}

public static void custoTodosArmazens()
{
int i,j;
double soma=0,somaTotal=0;

for (i=0; i<3; i++)
{
for (j=0; j<3; j++)
{
soma=soma+matriz[i][j]*custo[j];
}
}
JOptionPane.showMessageDialog(null, "O custo total em todos os armazens é "+soma);
System.exit(0);
}

public static void main (String args[])
{
lerEstoque();
dadosPorArmazem();
maisProduto2();
custoTotalUnitario();
custoTotalPorArmazem();
custoTodosArmazens();
}

}

//Exercicio para ler 2 vetores A e B c/ 20 elementos. Construir
// um terceiro vetor C contendo os valores de A X B