Java - algoritmo numeros crecientes y decrecientes

Pos: 27

Val: 189

algoritmo numeros crecientes y decrecientes

Publicado por Oliver (67 intervenciones) el 29/04/2018 22:56:48

buenas tardes comunidad necesito de su ayuda , estoy haciendo un algoritmo que me ayude a determinar que numeros son crecientes y decrecientes .

creciente = 123 (el digito de la derecha siempre debe ser mayor o igual )
decreciente = 321(el digito de la derecha debe ser menor o igual ).

en mi algoritmo se me pide que ingrese un valor que sustituya n como exponente de de la potencia 10^n, si coloco un 2 serian 100, si coloco 3 serian 1000 y bueno dado el resultado de la potencia debo determinar cuantos numeros crecientes y decrecientes hay en el rango del resultado... yo comence el algoritmo pero en el momento de realizar lka condicion para determinar que cada numero sea creciente o decreciente me quedo trabado ... esto es lo que llevo hasta ahora

import java.util.Scanner;

import java.util.Arrays;

public class Funcion

    public static void main (String [] args){

        Scanner ent = new Scanner (System.in);

        int exp = 0;

        System.out.println("inserte exponente :");

        exp = ent.nextInt();

        double numero =Math.pow(10,exp);

        // hacemos entero el resultado de la potencia

        int numeroInt = (int) numero;

        for(int i = 0; i <= numeroInt ; i++ ){

            // determinamos longitud del numero

            int longitud = Integer.toString(i).length();

            int cifra = i;

            // Declaramos un array con la longitud de la cifra

            int [] arreglo = new int[longitud];

            //Declaramos un bucle para separar la cifra en digitos e insertarla en el array

            for (int j = 0 ; j <= longitud-1 ; j++){

                //utilizamos residuo para tomar el ultimo numero de la cifra , posteriormente la dividimos entre 10 para irla reduciendo

                // 1000%10 = 0, luego 1000/10 = 100 luego repetimos 100%10 = 0, luego 100/10 = 10 y asi sucesivamente con cada cifra

                int residuo = cifra %10;

                cifra = cifra/10;

                arreglo[j]=residuo;

                //System.out.print(residuo);

            //System.out.print(Arrays.toString(arreglo));

            //System.out.println("");

Valora esta pregunta

Me gusta: Está pregunta es útil y esta clara

No me gusta: Está pregunta no esta clara o no es útil

Responder

Pos: 20

Val: 247

algoritmo numeros crecientes y decrecientes

Publicado por kingk (108 intervenciones) el 30/04/2018 16:50:09

Hola. ¿Podrias mostrar un ejemplo de cual debería ser el resultado, si se ingresa el numero 2?

Valora esta respuesta

Me gusta: Está respuesta es útil y esta clara

No me gusta: Está respuesta no esta clara o no es útil

Comentar

Pos: 27

Val: 189

algoritmo numeros crecientes y decrecientes

Publicado por Oliver (67 intervenciones) el 30/04/2018 22:20:28

Hola Kingk , te dare un ejemplo :

ingrese el exponente de la funcion 10^n :
2
el resultado de la funcion 10^2 es : 100 y la cantidad de crecientes y decrecientes es : 100
_________________________________________________________________________

otro ejemplo :
ingrese el exponente de la funcion 10^n :
3
el resultado de la funcion 10^3 es : 1000 y la cantidad de crecientes y decrecientes es : 475
__________________________________________________________________________

en el primero todos los numeros del 0 al 100 son creciente y decrecientes porque cumplen la condicion
1.- creciente = 1er digito >= 2digito
2.-decreciente = 1er digito <= 2digito
.... ahora bien cuando se eleva la potencia a 3 y el resultado es 1000 se valida un rango de cifras mas altas y es cuando aparecen numeros como 101, 102,103, etc y estas no cumplen la regla condicional , es decir ; no son cifras crecientes o decrecientes !!!

Valora esta respuesta

Comentar

Pos: 46

Val: 90

algoritmo numeros crecientes y decrecientes

Publicado por Simon (25 intervenciones) el 01/05/2018 14:08:58

No se muy bien donde hces la comprobacion de la condicion, pero en principio tienes que comparar la ultima posicion del array arreglo(la primera del numero que recoge, por la izquierda) con la penultima, si esta es igual mirar la posicion antepenultima y asi sucesivamente, si la penultima es < que la ultima signifa decreciente y si es mayor es creciente.
Espero haberte ayudado

Valora esta respuesta

Comentar

Pos: 27

Val: 189

algoritmo numeros crecientes y decrecientes

Publicado por Oliver (67 intervenciones) el 01/05/2018 20:35:06

Hla Simon gracias por la ayuda pero el algoritmo va un poco mas alla de lo que me planteas , quizas he sido yo que no me he sabido explicar !!!

Valora esta respuesta

Comentar

Pos: 20

Val: 247

algoritmo numeros crecientes y decrecientes

Publicado por kingk (108 intervenciones) el 01/05/2018 20:04:28

Hola, tal vez este codigo te sirva de guia:

int nn=11,mm=10,contador=0,contador2=0,num;

    Scanner sc=new Scanner(System.in);

    System.out.println("Ingrese el exponente:");

    int n=sc.nextInt();

    num=(int)Math.pow(10, n);

    while(nn<=num){

        System.out.print(nn+"|");

        nn++;

        contador++;

        int cc=String.valueOf(nn).length()-1;

        while(cc>=0){

            int exp=(int) Math.pow(10, cc);

            int dig=(nn/exp)%10;

            cc--;

            if(dig>(nn/Math.pow(10, cc))%10){

                nn+=dig*Math.pow(10, cc);

};

    System.out.println();

    System.out.println("Son "+contador +" numeros crecientes");

    mm=10;

    while(mm<=num){

        System.out.print("|"+mm);

        mm++;

        contador2++;

        int cc=0;

        while(cc< String.valueOf(mm).length()-1){

            int exp=(int) Math.pow(10, cc);

            cc++;

            int exp2=(int)Math.pow(10, cc);

            int dig=(mm/exp)%10;

            if(dig>(mm/exp2)%10){

                mm+=exp2;

                mm-=dig*exp;

    System.out.println();

    System.out.println("Son "+contador2 +" numeros decrecientes");

    System.out.println("Total numeros crecientes y decrecientes: "+(contador+contador2));

Espero haberte ayudado.

Valora esta respuesta

Comentar

Pos: 27

Val: 189

algoritmo numeros crecientes y decrecientes

Publicado por Oliver (67 intervenciones) el 01/05/2018 20:22:14

Hola kingK , el codigo esta bien solo que los numeros que son iguales como el 777, 666 y todos los similares son contados tanto en los crecientes y los decrecientes y eso genera un error pues se estaria contando dos veces , lo unico que hay que hacer es que si me lo conto como creciente que ya no lo cuente como decreciente para que me de la cantidad exacta de esta tabla :

exponente                       resultado                     crecientesDecrecientes

1                                 10                                    10

2                                 100                                   100

3                                 1000                                  475

4                                 10000                                 1675

5                                 100000                                4954

6                                 1000000                               12952

Si no es mucha molestia por favor , me podrias decir que significan las variables que declaras con iniciales porque la idea es que comprenda lo que has hecho pero la verdad me resulta muy dificil pues no tengo un concepto de la variable , no es tanto que el codigo funcione sino que pueda yo evaluar la logica del algoritmo a ver en que estaba fallando , de todas maneras muchas gracias por el aporte no espera menos de ti , haces muy buenos algoritmos !!!

Valora esta respuesta

Comentar

Pos: 20

Val: 247

algoritmo numeros crecientes y decrecientes

Publicado por kingk (108 intervenciones) el 02/05/2018 01:32:22

Hola, ire paso por paso:

int nn=11,mm=10,contador=0,contador2=0,num;

Las variables nn y mm son para almacenar los numeros crecientes(nn) y los numeros decrecientes(mm), y las variables contador1 y contador2 serian sus respectivos contadores.

while(nn<=num){

    System.out.print(nn+"|");

    nn++;

    contador++;

    int cc=String.valueOf(nn).length()-1;

    while(cc>=0){

        int exp=(int) Math.pow(10, cc);

        int dig=(nn/exp)%10;

        cc--;

        if(dig>(nn/Math.pow(10, cc))%10){

            nn+=dig*Math.pow(10, cc);

};

Dentro del while se incrementa en 1 el numero nn y su contador. Posteriormente en una variable cc almaceno la cantidad de digitos que tiene el numero. Como el numero se incrementa en 1 solamente, dentro de un while se revisa si el numero incrementado cumple las condiciones, y lo hace de esta forma:

//Se obtiene los digitos del numero de izquierda a derecha

int exp=(int) Math.pow(10, cc);

int dig=(nn/exp)%10; //La variable dig almacena un digito del numero

cc--;

if(dig>(nn/Math.pow(10, cc))%10){

//Si el digito obtenido es mayor al siguiente digito

    nn+=dig*Math.pow(10, cc); //Se le suma el el digito al digito en la posicion del siguiente digito

Por ejemplo si el numero es 20, digito1=2, y el digito2=0, se comparan los dos datos, 1>2, y como 2 es mayor a 0, se suma el valor de digito1 al digito en la posicion del digito2, 20+2=22

Para los decrecientes es de igual forma, solo que se extraen los digitos del numero de derecha a izquierda

Valora esta respuesta

Comentar

Pos: 27

Val: 189

algoritmo numeros crecientes y decrecientes

Publicado por Oliver (67 intervenciones) el 02/05/2018 04:17:21

Sos un crack mijo , mil gracias ... [email protected] ahi esta mi hangouts por si te interesa algun contacto en Colombia !!!

Valora esta respuesta

Comentar

Pos: 20

Val: 247

algoritmo numeros crecientes y decrecientes

Publicado por kingk (108 intervenciones) el 02/05/2018 01:34:06

Aqui esta el codigo modificado para obtener el resultado que deseas

int nn=1,mm=1,contador=0,contador2=0,num;

Scanner sc=new Scanner(System.in);

System.out.println("Ingrese el exponente:");

int n=sc.nextInt();

num=(int)Math.pow(10, n);

ArrayList<Integer> cre=new ArrayList<Integer>();

while(nn<=num){

    cre.add(nn);

    System.out.print(nn+"|");

    contador++;

    nn++;

    int cc=String.valueOf(nn).length()-1;

    while(cc>=0){

        int exp=(int) Math.pow(10, cc);

        int dig=(nn/exp)%10;

        cc--;

        if(dig>(nn/Math.pow(10, cc))%10){

            nn+=dig*Math.pow(10, cc);

};

System.out.println();

System.out.println("Son "+contador +" numeros crecientes");

while(mm<=num){

    System.out.print("|"+mm);

    if(!cre.contains(mm)){contador2++;}

    mm++;

    int cc=0;

    while(cc<String.valueOf(mm).length()-1){

        int exp=(int) Math.pow(10, cc);

        cc++;

        int exp2=(int)Math.pow(10, cc);

        int dig=(mm/exp)%10;

        if(dig>(mm/exp2)%10){

            mm+=exp2;

            mm-=dig*exp;

System.out.println();

System.out.println("Son "+contador2 +" numeros decrecientes");

System.out.println("Total numeros crecientes y decrecientes: "+(contador+contador2));

Valora esta respuesta

Comentar

Pos: 45

Val: 96

algoritmo numeros crecientes y decrecientes

Publicado por kip (20 intervenciones) el 01/05/2018 23:41:53

Hola, aquí te dejo algo que hice para ver si te sirve, el código podría reducirse ya que las operaciones para obtener los dígitos del numero son las mismas en cada caso pero creo que así como esta resulta mas fácil si alguien recién esta iniciando.

import java.util.Scanner;

class Main {

  public static void main(String[] args) {

    Scanner in = new Scanner(System.in);

    System.out.printf("Number to replace exponent of 10^n:  ");

    int mainNumber = (int) Math.pow(10, in.nextInt());

    int copyMainNumber = mainNumber,

      decrescents = 0,

      crescents = 0,

      sameDigits = 0,

      lessThan10 = 0;

    while (copyMainNumber > 0) {

      if (copyMainNumber < 10) {

        lessThan10++;

      } else if (hasSameDigits(copyMainNumber)) {

        sameDigits++;

      } else if (isDecrescent(copyMainNumber)) {

        decrescents++;

      } else if (isCrescent(copyMainNumber)) {

        crescents++;

      copyMainNumber--;

    System.out.printf(

      "Number: %d\nDecrescents: %d\nCrecents : %s\nSame digits: %d\nLess than 10: %d",

      mainNumber, decrescents, crescents, sameDigits, lessThan10

);

  public static boolean hasSameDigits(int number)

    int aux;

    int digit = number % 10;

    number = number / 10;

    while (number > 0) {

      aux = number % 10;

      if (digit != aux) {

        return false;

      digit = aux;

      number = number / 10;

    return true;

  public static boolean isDecrescent(int number)

    int aux;

    int digit = number % 10;

    number = number / 10;

    while (number > 0) {

      aux = number % 10;

      if (digit > aux) {

        return false;

      digit = aux;

      number = number / 10;

    return true;

  public static boolean isCrescent(int number)

    int aux;

    int digit = number % 10;

    number = number / 10;

    while (number > 0) {

      aux = number % 10;

      if (digit < aux) {

        return false;

      digit = aux;

      number = number / 10;

    return true;

El resultado por ejemplo de ingresar 3 te mostrara:

Number: 1000

Decrescents: 256

Crecents : 192

Same digits: 18

Less than 10: 9

Si hacemos la suma da un total de 475 tal como lo mencionas, para obtener los números que no entran en ningún caso bastaría con hacer una resta y listo.

Valora esta respuesta

Comentar

Validar combobox y enviar datos a mysql

ayuda para agregar objetos a un arryalist