Eu estou aqui com um livro sobre Java aberto(DEITEL) e surgiu um exercício que está me desafiando porque realmente não sei como posso chegar a tal façanha só com o que aprendi até agora no desenvolvimento dos temas.
O exercício é esse:
6.26 Write a method that takes an integer value and returns the number with its digits reversed. For example, given the number 7631, the method should return 1367. Incorporate the method into an application that reads a value from the user and displays the result.
Tradução:
6.26 Escreva um método que pega um valor inteiro e retorna o número com seus dígitos invertidos. Por exemplo, dado o número 7631, o método deverá retornar 1367. Incorpore o método dentro de uma aplicação que lê o valor do usuário e mostre o resultado.
Eu só gostaria de saber como é que vou fazer para ‘inverter’ o tal número. Alguma idéia de algoritmo? Alguma ajuda?
Eu imagino que o nível de resolução pretendida pelo autor do livro é apenas usando os operadores matemáticos, com as estruturas de controle e um pouco de orientação a objetos. Essa parte de montar o programa eu sei, trabalhar com os métodos, criar o objeto e manipular! Apenas preciso mesmo é de alguma idéia de como fazer tal ‘inversão’ só com o que vi até agora no livro. Ok?
primeiramente vc precisa converter isso para um String e depois um for
regressivo pode ser usado conforme o código abaixo :
public class TesteGeral {
public static void main(String[] args) {
Integer a = new Integer(7631);
String b = a.toString();
String c = "";
for (int i=b.length(); i > 0; i--) {
c += b.substring(i - 1, i);
}
System.out.println("numero invertido:" + c);
}
}
Gente, muito obrigado pelas respostas.
Realmente ajudaram muito!
adolfo_eloy, eu vou guardar o script feito por você para estudá-lo mais para frente. Eu ainda não estudei até agora a conversão, nem os métodos toString e subString. Mas mais para frente será útil sem dúvida alguma! Muito obrigado.
Aldrin Leal, você captou exatamente o que eu precisava. Cara, eu nunca ia chegar nesse algoritmo só pelo que o DEITEL ensinou no livro. Eu acho que ele pecou um pouquinho em não dar um exemplo dessa ‘inversão’, afinal essa lógica é um tanto quanto adversa em relação às demais.
Eu vou postar o código para quem se interessar pelo assunto ou para os fãs do google que futuramente chegarão através do mesmo aqui ao GUJ!
O código FUNCIONA.
import java.util.Scanner;
public class Exercicio626 {
private Scanner entrada = new Scanner(System.in);
public void pegaNumero(){
System.out.print("Digite a seguir o número a ser invertido: ");
int numero = entrada.nextInt();
inverte(numero);
}
private void inverte(int numero){
int i = 0;
while (numero > 0) {
i *= 10;
i += (numero % 10);
numero /= 10;
}
System.out.printf("O número invertido é: %d.\n", i);
}
}
public class Exercicio626Teste {
public static void main(String[] args) {
Exercicio626 objeto = new Exercicio626();
objeto.pegaNumero();
}
}
E por fim, olhe a saída do código tendo digitado no input o número dado no enunciado:
[quote]Digite a seguir o número a ser invertido: 7631
O número invertido é: 1367.[/quote]
Abraços e obrigado novamente pela ajuda,
Giancarlo.
Boa tarde, estou estudando java tb… e estou tentando entender a lógica utilizada
Utilizando matemática:
int i0 = 7631;
int i = 0;
while (i0 > 0) {
i *= 10;
i += (i0 % 10);
i0 /= 10;
}
eu realizei o meu baseando nisto:
class AulaInverter {
public static void main(String args[]) {
int numeroInverte = 123456789;
int numeroInvertido = 0;
while (numeroInverte > 0) {
numeroInvertido = numeroInvertido *10;
numeroInvertido = numeroInvertido + (numeroInverte % 10);
numeroInverte = numeroInverte / 10;
}
System.out.println(numeroInvertido);
}
}
Deu certo, executou o que eu estava precisando, (eu modifiquei (simplifiqueis as operações para tentar entender o que ele estava fazendo) confesso que não entendi, poderiam me explicar por favor…
pq… pelo teste que identifiquei ali… o numeroInverte é maior que zero no primeiro momento, então ele entra no looping, ai… ele pega o numeroInvertido que no momento é zero e multiplica por 10, ou seja … resulta em 0 , ai depois ele armazena nesta váriavel o resto da divisão do numeroInverte, e ai divide o número inverte por 10 ,
sinceramente não to entendendo o que ele esta executando…
public static void main(String args[]) {
int numeroInverte = 123456789;
int numeroInvertido = 0;
/* Enquanto (123456789 > 0) Faca */
/* No proximo while sera */
/* Enquanto (12345678 > 0) Faca */
/* Quando terminar a ultima divisão ou seja numeroInverte = 1 / 10 = 0, o contador para */
while (numeroInverte > 0) {
/* Inicia com numeroInvertido 0 = 0 x 10 = 0 */
/* No proximo while numeroInvertido sera
/* 9 x 10 = 90 */
numeroInvertido = numeroInvertido *10;
/* numeroInvertido recebe 0 = 0 + (%) Resto da Divisão numeroInverte 0 */
/* (%) Retorna o resto de uma divisão por um numero no caso acima 10:
/* 123456789 / 10 = 12345678 e Seu resto 123456789 % 10 = 9, */
/* No proximo while sera
/* 12345678 / 10 = 1234567 e Seu resto 12345678 % 10 = 8, */
/* 0 = 0 + ( 9 )*/
numeroInvertido = numeroInvertido + (numeroInverte % 10);
/* 123456789 = 123456789 / 10 - numeroInverte passa a valer 12345678 */
/* No proximo while
/* 12345678 = 12345678 / 10 - numeroInverte passa a valer 1234567 */
numeroInverte = numeroInverte / 10;
}
/* Mostra o resultado da inversao de numeros */
System.out.println(numeroInvertido);
}
Oi gasmg, bem-vindo ao fórum.
Cuidado ao ressuscitar tópicos muito antigos. Se for faze-lo (como o caso desse, de 1 ano e meio atrás, que estava sem resposta), pelo menos evidencie isso na sua postagem.
Ao postar códigos, use também a tag code, para deixa-lo formatado. Veja como aqui:
Ola pessoal o exercício proposta na apostila que adquiri para estudar é o seguinte :
Desenvolva um programa que solicita ao usuário um número inteiro de no máximo 4 dígitos. Inverta esse número.
o que eu fiz para resolver este problema foi:
import java.util.Scanner;
public class Exercicio9 {
public static void main(String[] args)
{
Scanner entrada = new Scanner(System.in);
int
numero,
comparador,
inverte;
comparador = 0;
inverte = 0;
while(comparador != 1)
{
System.out.print("Digite um numero que no máximo contenha 4 digitos: ");
numero = entrada.nextInt();
if(numero > 9999)
{
System.out.print(numero + " ultrapassou os 4 digitos\n");
}
else
{
while(numero > 0)
{
inverte *= 10;
inverte += (numero % 10);
numero /= 10;
}
System.out.print("O numero invertido e = " + inverte + "\n");
comparador = 1;
}
}
}
}
Gostaria que por gentileza alguém me confirma-se se desta forma esta correta ou se na opção para delimitar uma quantidade de valores isso deveria ser feito de uma outra forma.
Sei que o tópico é antigo, mas gostaria se possível de uma ajuda da galera que fez esse exercício ou de quem também procurar por este tópico! Sendo assim, fiz uma solução para esse exercício (um milhão de variáveis, rsrs), entretanto, o mesmo não executa a inversão de valores para centenas e milhares, o programa só inverte os valores em dezenas. Segue abaixo para que, por favor, alguém me dê uma luz de onde eu errei!
import java.util.Scanner;
public class DigitosInvertidos {
private int num;
private int numDez;
private int numCent;
private int numMil;
private int dez1;
private int dez2;
private int cent1;
private int cent2;
private int cent3;
private int mil1;
private int mil2;
private int mil3;
private int mil4;
Scanner input = new Scanner(System.in);
// método para obter o valor e testar seu tamanho para a inversão
public void obtemValor(){
System.out.println("Informe um valor entre (10 e 9999):");
num = input.nextInt();
while ( num < 10 || num > 9999 ) {
System.out.println("Entrada Inválida! Informe um valor entre (10 e 9999):");
num = input.nextInt();
}
if (num >= 10 || num <= 99) {
numDez = num;
dez2 = numDez % 10;
numDez = numDez / 10;
dez1 = numDez % 10;
System.out.printf("O valor invertido é: %d%d\n", dez2, dez1);
} else if (num >= 100 || num <= 999) {
numCent = num;
cent3 = numCent % 10;
numCent = numCent / 10;
cent2 = numCent % 10;
numCent = numCent / 10;
cent1 = numCent % 10;
System.out.printf("O valor invertido é: %d%d%d\n", cent3, cent2, cent1);
} else if (num >= 1000 || num <= 9999) {
numMil = num;
mil4 = numMil % 10;
numMil = numMil / 10;
mil3 = numMil % 10;
numMil = numMil / 10;
mil2 = numMil % 10;
numMil = numMil / 10;
mil1 = numMil % 10;
System.out.printf("O valor invertido é: %d%d%d%d\n", mil4, mil3, mil2, mil1);
}
}
}
public class TestaDigitosInvertidos {
public static void main(String[] args) {
DigitosInvertidos testa = new DigitosInvertidos();
testa.obtemValor();
}
}
Sei que o tópico é antigo, mas gostaria se possível de uma ajuda da galera que fez esse exercício ou de quem também procurar por este tópico! Sendo assim, fiz uma solução para esse exercício (um milhão de variáveis, rsrs), entretanto, o mesmo não executa a inversão de valores para centenas e milhares, o programa só inverte os valores em dezenas. Segue abaixo para que, por favor, alguém me dê uma luz de onde eu errei!
import java.util.Scanner;
public class DigitosInvertidos {
private int num;
private int numDez;
private int numCent;
private int numMil;
private int dez1;
private int dez2;
private int cent1;
private int cent2;
private int cent3;
private int mil1;
private int mil2;
private int mil3;
private int mil4;
Scanner input = new Scanner(System.in);
// método para obter o valor e testar seu tamanho para a inversão
public void obtemValor(){
System.out.println("Informe um valor entre (10 e 9999):");
num = input.nextInt();
while ( num < 10 || num > 9999 ) {
System.out.println("Entrada Inválida! Informe um valor entre (10 e 9999):");
num = input.nextInt();
}
if (num >= 10 || num <= 99) {
numDez = num;
dez2 = numDez % 10;
numDez = numDez / 10;
dez1 = numDez % 10;
System.out.printf("O valor invertido é: %d%d\n", dez2, dez1);
} else if (num >= 100 || num <= 999) {
numCent = num;
cent3 = numCent % 10;
numCent = numCent / 10;
cent2 = numCent % 10;
numCent = numCent / 10;
cent1 = numCent % 10;
System.out.printf("O valor invertido é: %d%d%d\n", cent3, cent2, cent1);
} else if (num >= 1000 || num <= 9999) {
numMil = num;
mil4 = numMil % 10;
numMil = numMil / 10;
mil3 = numMil % 10;
numMil = numMil / 10;
mil2 = numMil % 10;
numMil = numMil / 10;
mil1 = numMil % 10;
System.out.printf("O valor invertido é: %d%d%d%d\n", mil4, mil3, mil2, mil1);
}
}
}
public class TestaDigitosInvertidos {
public static void main(String[] args) {
DigitosInvertidos testa = new DigitosInvertidos();
testa.obtemValor();
}
}
[/quote]
Minha dúvida foi resolvida no tópico em que criei sobre a mesma!
O fórum GUJ é o melhor para Java sem sombra de dúvidas, valeu galera!
