Numero 9 sempre analisar

31 de março de 2015 12 respostas

soloplayer 31 de março de 2015

Olá, gostaria de saber se alguém sabe como analisar sempre um serie de numero se for 9, ou 19, ou 29, e ai por dia,te. Grato.

12 Respostas

adriano_si 31 de mar. de 2015

Algoritmo
#############################

Pegue o número da entrada;
Transforme o número em String;
Pegue o último caractere da String;
Compare se esse último caractere é igual a 9;
#############################

1 - Pegue o número de entrada:

Se você já tem o número, pode pular esse passo, se não tem, pode dar uma pesquisada na classe Scanner ou JOptionPane.

2 - Transforme o número em String:

Aqui você pode usar o próprio construtor da classe String, ou o método toString() caso o seu número seja um objeto do tipo Integer ou Long, etc.

3 - Pegue o último caractere da String:

Aqui eu aconselho a usar o método charAt() da própria classe String ou então o método substring(). Uma dica aqui é verificar que índices em Java começam com o valor 0;

4 - Com esse caractere obtido, basta fazer uma comparação de igualdade usando o método equals() se for String ou == se for inteiro, e receber uma resposta booleana (true ou false);

PS: As etapas 3 e 4 podem ser feitas no mesmo momento.

Tenta fazer e nos posta o que conseguiu.

Abraços

soloplayer 31 de mar. de 2015

Olá amigo obrigado pela presteza, mas é o seguinte, e se o cara digitar 8.9?

Como este exemplo que fiz.

double x = 8.9;
		String b;
		String valorStr = String.valueOf(x);
		Character charUltimo =  valorStr.charAt(valorStr.length()-1);
		String valueStrConvertExChar = Character.toString(charUltimo);  
		
		String nomeSemPontoJava = valueStrConvertExChar.replace(".", "");
		System.out.println("Sem ponto " +nomeSemPontoJava);
		
		if(valueStrConvertExChar.equals("9")) {
			System.out.println("Ultimo é igual a 9: "+valorStr.charAt(valorStr.length()-1));
			
		}else{
			System.out.println("Ultimo é diferente de 9: "+valorStr.charAt(valorStr.length()-1));
		}

Na verdade gostaria de sempre, por exemplo, se a pessoa digitar que seja, 15.9 ele sempre arredondar para sua seguencia de 9, ou seja, de 10 em 10 se ele digitar 25.9, ele arredonta para 29, e se 35 ele arredonda para 39, e ai por diante, como por exemplo digitar 289, esta correto percorrendo e exibindo somente ele, fiz um outro algoritmo, grato.

BigDecimal bd = new BigDecimal ("1.23");
		System.out.println (bd); // imprime "1.23", não "5.79"
		bd = bd.add (new BigDecimal ("289.00"));
		System.out.println (bd); // imprime "5.79"


		//Integer cont = Integer.valueOf(bd.toString());
		int contador = ((BigDecimal)bd).intValue();
		
		System.out.println("contador "+contador);
		
		for(int i = 0; i<= contador+10; i = i+10)
		{
			int ii = i;
			ii = ii -1;
			
			System.out.println("Multiplos de 10-1: " +ii+ " | Contador: " +contador);	
		}

Resultado:

Sendo que quando 289, teria que mostra ele, e não a ultima linha. Abraço.

getAdicted 31 de mar. de 2015

Eu ia sugerir o resto da divisão, mas com a API eh muito mais conveniente… rs

[]'s

soloplayer 31 de mar. de 2015

Como ficaria amigão, pode me dar um exemplo? Abraço

getAdicted 31 de mar. de 2015

numero % 10 retorna a ultima dezena, no caso, 9! Tem varias formas de se resolver isso, inclusive, fazendo uso da API como o nosso ilustre amigo postou acima.

[]'s

getAdicted 31 de mar. de 2015

Mas para arredondar use BigDecimal com round, etc…

[]'s

soloplayer 31 de mar. de 2015

Consegue me dar um exemplo bem simples amigo? Grato.

getAdicted 31 de mar. de 2015

soloplayer:
Consegue me dar um exemplo bem simples amigo? Grato.

public class Main {

	public Main() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String... strings) {

		int i = 111119 % 10;

		System.out.println(i);

	}

}

Cara, eu jah fiz muito uso da classe BigDecimal, se eu não me falha a memoria, eh um metodo round que recebe uma constante "floor, higher", etc...

[]'s

misterzire 31 de mar. de 2015

package funcoes;

public class ComparaString {

	public static void main(String[] args) {
		
		String parametro = "198.87989";
		
		char compararComValorIgualA = '9';
				
		if ( ComparaUltimoCaracterString(parametro,compararComValorIgualA) == true  ){
			
			System.out.println("aprovado!");
			
		}
		else
		{
			System.out.println("reprovado!");
			
		} 
		
				
		
	}
	
	
	static Boolean ComparaUltimoCaracterString(String campo , char valoraComparar){
	
		if (campo != null && campo.length() > 0) {  

            
			char caractere =  campo.charAt(campo.length() - 1) ;
			
			System.out.print("Ultimo caratere é ");
			System.out.println(caractere);
			
			if ( valoraComparar==caractere) {
				
				return  true;
			}
			else
			{
				return  false;
			}
            
            
        } 
		else
		{	
        return false;  
		}
		
	}
	
;
}

Ve se funciona !

soloplayer 31 de mar. de 2015

Ola amigo, a logica esta certo, mas na linha “String parametro = “17.9”;” 5, por exemplo, ele teria que erredondar para 19,00 entende, sendo que teria que fazer um laço ou alguma coisa, se eu digitatar 1.45, 6.9 ou 8.9, estes valores me obrigam a arredondar para 9, assim como se digitar 11.9 tenho que arredondar para sempre acima 19, ou seja, se for 25.9 também, entendeu, é como um calculo de juros estipulado para promoção, mas que sempre ficará em 9, 19, 29, 289 e ai por diante. Conseguiram entender. Abraço.

E obrigado por enquanto.

soloplayer 1 de abr. de 2015

Bom dia pessoal, alguém mais tem a solução com BigDecimal? Abraço.

soloplayer 2 de abr. de 2015

Pessoal, consegui chegar em um resultado quase lá, mas agora é o seguinte, precisava arrumar uma forma de sempre arredondar para 9, 19, 29, 39 e respeitando que se a pessoa digitar 29.1 arredonda para 39, e ai por diante.

import java.math.BigDecimal;
import java.math.RoundingMode;

import javax.swing.JOptionPane;

public class TesteNotaArredondada {

	public static void main(String[] args) {

		double valorArredondado = 0.0;
		// double valor =
		// Double.valueOf(JOptionPane.showInputDialog("Entre com valor"));
		double valor = 9.15;
		int valorInteiro = (int) valor;

		double resto = valor - valorInteiro;

		System.out.println("Valor: " + valor);
		System.out.println("Valor inteira: " + valorInteiro);
		System.out.println("Resto: " + resto);
		System.out.println("\n \n ");

		if (resto > 0) {
			if (resto <= 0.5) {
				valorArredondado = valorInteiro + 0.9;
			} else {
				valorArredondado = valorInteiro + 0.9;
			}
		}

		System.out.println("Valor arredondado: " + valorArredondado);

		/* agora com BigDecimal */
		BigDecimal valorArredondadoBd = new BigDecimal(0.0);
		BigDecimal valorBd = new BigDecimal(21.22);

		// int notaInteiraa = ((BigDecimal)notaa).intValue();
		BigDecimal valorInteiroBd = valorBd.setScale(0, RoundingMode.CEILING);
		BigDecimal valorInteiroFloor = valorBd.setScale(9, RoundingMode.FLOOR);

		BigDecimal restoa = valorBd.subtract(valorInteiroBd);

		System.out.println(" Preço: " + valorBd);
		System.out.println(" Preco int " + valorInteiroBd);
		System.out.println(" Preco int floor " + valorInteiroFloor);
		System.out.println(" Resto " + restoa);

		Float sa = new Float(valorArredondadoBd.add(valorInteiroBd).setScale(2, 2)
				.floatValue() + 0.9);

		if (restoa.floatValue() > 0) {
			if (restoa.floatValue() <= 0.5) {
				valorArredondadoBd = new BigDecimal(sa);
			} else {
				valorArredondadoBd = new BigDecimal(sa);
			}
		}

		System.out.println("Preco Arredondado BigDecimal: " + sa);

		restoa = valorBd.add(valorInteiroBd);

	}
}

Neste Algoritmo bem simples que fiz, na linha 59 "System.out.println(“Preco Arredondado BigDecimal: " + sa);” ele exibe 22,90, isso foi uma jogada que fiz, não respeitando a numeração, mas na verdade queria que ele arredondasse para 29,00, e se o resultado fosse, 34.89 ficaria 39.00 se fosse 8.87 ele ficaria 9, e ai por diante, o ultimo é utilizando o BigDecimal, porque preciso de precisão, abraço a todos.

Criado 31 de março de 2015

Ultima resposta 2 de abr. de 2015

Respostas 12

Participantes 4

12 Respostas

Topicos relacionados