Matching numbers greater than 40

Question

I'm trying to match numbers greater than 40. The good point is that all of them have 2 decimal places, so all of them are like: 3.25, 5.89, 999.75 and they don't use any leading zeros (except on the decimal part that always have 2 digits)... At first I tried the following code but then I realized this wouldn't match numbers like 100, 1000... even if they are greater than 40.

[4-9][0-9]\.

I don't have to match the decimal part, so don't worry about matching that, just help me to find how to match numbers greater than 40 (up to 9999 would be fine).

Thanks for your help.

Answer 1

This should do the job:

([4-9][0-9]|\d{3,})\.

Check it here: http://www.regexr.com/3a5v9

Answer 2

Don't use regular expressions for number comparison. If, for example, you're using Javascript:

var aNumber = parseFloat("50");
if (aNumber > 40) {
    // yay!
}

Answer 3

You can use brackets to indicate a minimum and, if desired, maximum number of characters to match. So,

([4-9][0-9]|[1-9][0-9]{2,})\.

matches 4-9 followed by one or more digits. Presumably there's a boundary of some sort at the beginning of this, but it sounds like you have that part worked out. This uses an OR to allow for two possible groups of first digits.

Answer 4

(40\.(?!0[^\d]|00)\d{1,2}|(((4[1-9](?!\d)|[5-9][0-9])(?![\d])|\d*[1-9]\d{2,})(\.\d{1,2})?))

This prevents false positives from leading 0s.

This worked for me.

• It tries to match 40 followed by 1 or two decimals that are not 00.
• It then tries to match 4 followed by 1-9, decimal optional.
• If it can't match that it matches 5-9 followed by 0-9, decimal optional.
• It then triese to match any digit, any number of times, followed by 1-9, followed by 1 or 2 digits, decimal optional.

If you want to require the decimal, just remove the last question mark.

Answer 5

This will do it:

([4-9][0-9]+|\d{3,})

This it will get all the numbers of two digits having the first one greater than 4 or any number with three digits.

As an example http://www.regexr.com/3a5v0

Answer 6

If your regex flavour can use negative lookbehind to match the numbers from 41 to 9999 without decimal:

\b(?:[1-9][0-9]{2,3}|[5-9][0-9]|4[1-9])(?<!\.\d{1,2})\b

Answer 7

(Most of the other answer are perfect for me -- This is paranoia and a bad idea :)

for use with grep -Po or Perl we could use:

'\b(\d{3,}|[4-9]\d)\.\d\d'

but this would get 40.00 (not greater than 40)

'\b(\d{3,}|[5-9]\d|4[1-9])\.\d\d|\b40\.\d?[1-9]\d?'

Corresponding to:

     DDD.DD 
| [5-9]D.DD
| 4[1-9].DD 
|     40.D[1-9] 
|     40.[1-9]D

Answer 8

In flex(1) you have this code to parse strings and get numbers greater than 40:

pru.l:

%option noyywrap
%%
\+?(0*[4-9][0-9]|0*[1-9][0-9][0-9][0-9]*)(\.[0-9]*)?  { printf("Greater than 40: %s\n", yytext); }
\-?[0-9]*(\.[0-9]*)?                                { printf("Lesser than 40: %s\n", yytext); }
\n                                                |
.                                                 ;
%%

int main()
{ yylex(); }

Install flex and compile this file it with

make pru

Then run it as:

pru <filein >fileout

or just

pru

This code constructs a deterministic finite automaton from the regular expressions listed and prints the commands listed on the right when recognizes a value greater than 40. It allows a leading optional sign and leading zeros, and an optional fractional part composed of any number of digits. And it does this with only one asignment and one decision for each character read. You have access to the automaton state table generated by flex (it writes C code for you)

the regex that recognizes numbers greater than 40 (with decimals and leading sign and zeros) is:

\+?(0*[4-9][0-9]|0*[1-9][0-9][0-9][0-9]*)(\.[0-9]*)?

and can be abreviated as:

\+?(0*[4-9][0-9]|0*[1-9][0-9]{3,})(\.[0-9]*)?

explanation:

• \+? matches an optional plus sign.
• (...|...) two options:
• 0* optional arbitrary number of leadin zeros.
• [4-9][0-9] the numbers 40 to 99
• [1-9][0-9]{3,} the numbers 100 and up.
• (.[0-9]*)? optional decimal point followed by an arbitrary number of digits.