TransWikia.com

Verificar número mayor a 50 millones

Stack Overflow en español Asked by sioesi on December 5, 2021

Necesito verificar si un número es mayor a 50.000.000, pero quiero evitar el típico:

if (numero > 50000000) {
   //....
}

¿Existe alguna manera de verificarlo con *regex", u otra manera?

5 Answers

Se puede hacer la comparativa en binario, o en cualquier otra base.

Usando el método toString, pasándole como argumento un número base, es decir, toString(base), podemos hacer la comparación del número en base 36, que es la máxima permitida por el método.

En este caso, si el string llega a tener una longitud igual a la del string tro8w, que es 50 millones en base 36, y además, que sea mayor alfabéticamente a ese string, o si tiene mayor longitud que la del string, nos tiene que devolver true.

function es_mayor_a_50_millones(valor)
{
  var b36=valor.toString(36)
  return b36.length==5 && b36>"tro8w" || b36.length>5
}
var valores=[
  35 ,
  40000000 ,
  50000000 ,
  50000001 ,
  50000001000
]
for(var i in valores)
{
  var valor=valores[i]
  console.log( valor, es_mayor_a_50_millones(valor) )
}

Answered by user13558 on December 5, 2021

Para los no tan "científicos":

function billones (n) {return n * 1e12};
function millones (n) {return n * 1e6};
function mil      (n) {return n * 1e3};

Y luego,

if (numero > millones(50)) {
   //....
}

O incluso,

var miNum = billones(9) + mil(millones(2)) + mil(321) + 654;
       // = 9,002,000,321,654;

Answered by Woody on December 5, 2021

Como aporte a las respuestas de Mariano y de Larry U, agrego una posible solucion, obviamente no tan elegante.

var X = 51000000;

if (X > (1000000 << 5) + (1000000 << 4) + (1000000 << 1)){
  console.log("X es mayor a 50 millones");
}
else{
  console.log("X es menor a 50 millones");
}

Usando desplazamientos de bits, genero los siguientes numeros:

(1000000 << 5)  =  32000000
(1000000 << 4)  =  16000000
(1000000 << 1)  =   2000000

Los cuales al sumar dan como resultado 50000000. Puede usarse para comparar y determinar si el numero es menor o mayor.

Actualizacion

He realizado una comparacion respecto a la velocidad con la que se podrian ejecutar dichas instrucciones, en relacion al comentario de @Ruben:

var t0 = performance.now();

/* Codigo */

var X = 51000000;

if (X > (1000000 << 5) + (1000000 << 4) + (1000000 << 1)){
  console.log("X es mayor a 50 millones");
}
else{
  console.log("X es menor a 50 millones");
}

/* Fin Codigo*/

var t1 = performance.now();

console.log("Tardo: " + (t1 - t0) + " milisegundos.");

var t0 = performance.now();

/* Codigo */

var X = 51000000;

if (X > 5e7) {
  console.log("X es mayor a 50 millones");
} else {
  console.log("X es menor a 50 millones");
}

/* Fin Codigo*/

var t1 = performance.now();

console.log("Tardo: " + (t1 - t0) + " milisegundos.");

Conclusion: La respuesta de Mariano, es mas eficiente, respecto a la velocidad en la ejecucion, como bien se puede apreciar en estos ejemplos.

Answered by Ivan Botero on December 5, 2021

Creo que usando regex, una cifra mayor a 50000000 se pueden representar de la siguiente forma:

  • Si la cifra tiene 8 dígitos, el primero de ellos no puede ser igual a 50000000

      ^0*(?:5(?!0{7})d{7}$
    
  • Agregamos el resto de las cifras de 8 dígitos mayores que 50000000

      ^0*[6-9]d{7}$
    
  • Si la cifra tiene mas de 8 dígitos, el primero de ellos debe mayor o igual que 1 (evita validar 9 ceros o mas)

      ^0*[1-9]d{8,}$
    
  • Cualquiera de estas cifras puede tener ceros infinitos 0* al inicio de las mismas.

Combinando estas expresiones nos queda:

^0*(?:5(?!0{7})|[6-9]|[1-9]d)d{7,}$

^ y $ son para garantizar que la variable sea un numero

(?: ) Agrupa elementos sin guardar ninguna referencia o enlace para futuros usos.

(?! ) Me ayuda a detectar un patrón después de cierta expresión y descartarlo, en este caso 7 ceros después de un 5.

Answered by Larry U on December 5, 2021

Para escribirlo más corto:

if (numero > 5e7) {
    //...
}

Eso es 5 * 10^7
(o "un 5 seguido de 7 ceros").


Y, no, no, no, no, no, no!!! No uses regex para algo tan sencillo como esto. Te va a hacer que una sentencia trivial se convierta en un elefante que intenta comer un maní a través del agujero de la cerradura... Para curiosos, el regex sería /^0*(?:(?:[6-9]|[1-5]d|5(?=0*[1-9])))d{7}/, pero no lo usen, y mucho menos digan que yo lo escribí.

  • Y esto no es solamente por repetir lo que todo el mundo dice. Utilizando una expresión regular estarías haciéndolo ~150 veces más lento (varía para cada caso). En un código intensivo, iría sumando demoras, tomando 1 segundo más cada ~4e8 iteraciones.

    Comparar en: JSPerf.

Answered by Mariano on December 5, 2021

Add your own answers!

Ask a Question

Get help from others!

© 2024 TransWikia.com. All rights reserved. Sites we Love: PCI Database, UKBizDB, Menu Kuliner, Sharing RPP