Autor Tema: Algoritmo para hallar el menor numero dentro de un vector  (Leído 24619 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado llAudioslavell

  • Trade Count: (0)
  • Sv Member
  • ***
  • Thank You
  • -Given: 12
  • -Receive: 3
  • Mensajes: 126
Algoritmo para hallar el menor numero dentro de un vector
« : enero 07, 2013, 03:20:16 pm »
Lo desarrolle yo mismo sin ver otros ejemplos y funciona muy bien, solo quisiera saber su opinión osea si es aceptable o aun se puede mejorar en algo

        int[] vector = {3,8,0};
        int rest=0; //resultado
        int n1=0;       
        int cont=0;
       
        for(int n=0; n<vector.length; n++){
            if (vector[n1]<vector[n]){
                cont++;
            }
            if (n==2){
                if (cont==2){
                    rest= vector[n1];
                }else{
                    n1++;
                    n=0;
                }           
               
            }
        }
        System.out.println(rest);

Desconectado ernestoch

  • Trade Count: (0)
  • MiembrosReales
  • *
  • Thank You
  • -Given: 1
  • -Receive: 3
  • Mensajes: 32
Re:Algoritmo para hallar el menor numero dentro de un vector
« Respuesta #1 : enero 07, 2013, 03:31:39 pm »
esta bien, lo simplifique un poco ...
Código: [Seleccionar]
        int[] vector = {3,8,0};
        int rest=vector[0]; //resultado
        for(int n=1; n<vector.length; n++){
            if (vector[n]<rest){
                rest = vector[n];
            }
        }
        System.out.println(rest);
nota que le reduje dos delcaraciones de variables y elimine todo un if, es decir, lo simplifiqué....
por supuesto que eventualmente podrias encapsular tu código en un método, pero funciona bien como dijiste.

EDIT: inicialicé n con 1 pues no tiene sentido comparar el elemento en la posición cero con el mismo.
« Última Modificación: enero 07, 2013, 03:42:01 pm por ernestoch »

Desconectado llAudioslavell

  • Trade Count: (0)
  • Sv Member
  • ***
  • Thank You
  • -Given: 12
  • -Receive: 3
  • Mensajes: 126
Re:Algoritmo para hallar el menor numero dentro de un vector
« Respuesta #2 : enero 07, 2013, 03:53:03 pm »
esta bien, lo simplifique un poco ...
Código: [Seleccionar]
        int[] vector = {3,8,0};
        int rest=vector[0]; //resultado
        for(int n=1; n<vector.length; n++){
            if (vector[n]<rest){
                rest = vector[n];
            }
        }
        System.out.println(rest);
nota que le reduje dos delcaraciones de variables y elimine todo un if, es decir, lo simplifiqué....
por supuesto que eventualmente podrias encapsular tu código en un método, pero funciona bien como dijiste.

EDIT: inicialicé n con 1 pues no tiene sentido comparar el elemento en la posición cero con el mismo.
ya entendi en donde esta mi error... me rio de mi algoritmo  :yao_ming: Muchas gracias !!!!!
« Última Modificación: enero 07, 2013, 03:56:02 pm por llAudioslavell »

Desconectado ~

  • Trade Count: (0)
  • The Communiter-
  • *
  • Thank You
  • -Given: 0
  • -Receive: 156
  • Mensajes: 1408
    • Ciencia de Computación, OSes y Herramientas
Re:Algoritmo para hallar el menor numero dentro de un vector
« Respuesta #3 : enero 07, 2013, 05:00:47 pm »
Un mejor ejemplo, inmediatamente compilable.

Usa el valor +Infinity en lugar de simplemente 0 para encontrar el menor valor de forma más acorde a las operaciones matemáticas:


MenorNumeroDouble.java
Código: [Seleccionar]
class MenorNumeroDouble
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     double[] vector = {3.3, 8.1, 0.7, -5.1, 3.4, 8.93, -2.07};




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static double encontrarMenor(double [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0 / 0.0;
     double rest = (+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=1; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n]<rest)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}


O usamos BigDecimal, para máxima precisión:

MenorNumeroBigDecimal.java
Código: [Seleccionar]
import java.math.BigDecimal;



class MenorNumeroBigDecimal
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     BigDecimal[] vector = {
                      new BigDecimal(3.3),
                      new BigDecimal(8.1),
                      new BigDecimal(0.7),
                      new BigDecimal(-5.1),
                      new BigDecimal(3.4),
                      new BigDecimal(8.93),
                      new BigDecimal(-2.07)
                     };




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static BigDecimal encontrarMenor(BigDecimal [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0/0.0;
     BigDecimal rest = new BigDecimal((long)+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=0; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n].compareTo(rest)<0)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}
Mi sitio web:
---- IP para archivo hosts (todos mis subdominios):
190.150.9.244 archefire.org

Desconectado llAudioslavell

  • Trade Count: (0)
  • Sv Member
  • ***
  • Thank You
  • -Given: 12
  • -Receive: 3
  • Mensajes: 126
Re:Algoritmo para hallar el menor numero dentro de un vector
« Respuesta #4 : enero 07, 2013, 09:08:50 pm »
Un mejor ejemplo, inmediatamente compilable.

Usa el valor +Infinity en lugar de simplemente 0 para encontrar el menor valor de forma más acorde a las operaciones matemáticas:


MenorNumeroDouble.java
Código: [Seleccionar]
class MenorNumeroDouble
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     double[] vector = {3.3, 8.1, 0.7, -5.1, 3.4, 8.93, -2.07};




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static double encontrarMenor(double [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0 / 0.0;
     double rest = (+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=1; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n]<rest)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}


O usamos BigDecimal, para máxima precisión:

MenorNumeroBigDecimal.java
Código: [Seleccionar]
import java.math.BigDecimal;



class MenorNumeroBigDecimal
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     BigDecimal[] vector = {
                      new BigDecimal(3.3),
                      new BigDecimal(8.1),
                      new BigDecimal(0.7),
                      new BigDecimal(-5.1),
                      new BigDecimal(3.4),
                      new BigDecimal(8.93),
                      new BigDecimal(-2.07)
                     };




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static BigDecimal encontrarMenor(BigDecimal [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0/0.0;
     BigDecimal rest = new BigDecimal((long)+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=0; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n].compareTo(rest)<0)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}
La verdad.... no entendi  :yao_ming:
Voy a tratar de comprenderlo