We Keep Coding

Working with RegEx, but I dont know how to approach my issue

^\d{1,12}$|(?=^.{1,15}$)^\d+\.\d{1,2}$
This is the expression I currently have.
I want the max limit to be 100 000 000 000 with optional two decimals max, but if the user only adds 1 decimal, they can bump the value to 100 000 000 0001.1 if they want to.
How can I approach this issue? and is there any way to make 100 000 000 000 the max value? (Not 999 999 999 999)

You can use the following regex to match numbers from 0 to 99999999999 with any two digits in the decimal part or 100000000000 with only zeros in the decimal part:
^(?:(?:[0-9]|[1-9][0-9]{1,11})(?:\.\d{1,2})?|10{11}(?:\.00?)?)$
See the regex demo.
^ - start of string
(?: - start of a non-capturing group:
(?:[0-9]|[1-9][0-9]{1,11}) - 0 to 99999999999 number
(?:\.\d{1,2})? - an optional sequence of a . char and then one or two digits
| - or
10{11}(?:\.00?)? - 1 and then 11 zeros optionally followed with . and one or two zeros
) - end of the group
$ - end of string.

^\d{1,12}$|(?=^.{1,15}$)^\d{1,12}\.\d{1,2}$
It seems the problem is the plus sign in the second part of the regex

For the part without the decimal I tried this :
^\d{1,11}$|^100000000000$|(?=^.{1,15}$)^\d+.\d{1,2}$
// works :
100000000000
// doesn't work :
999999999999
I don't know for the decimal part.

try this
^\d{1,12}(?:\.\d{1,2})?$
https://regex101.com/r/FcRDII/1
for the max value being 100 000 000 000, i would not validate that with regex, but if you have no other options this might work
^(?:1[0]{11}|\d{1,11})(?:\.\d{1,2})?$
https://regex101.com/r/V6b1Fv/1

Regex for non negative and non zero for the format ###.##

I have a requirement to validate some inputs which should be in format ###.##
Invalid inputs are:
-11.10 ==> no negative
000.00 or 0 ==> 0 not allowed should be positive
Valid inputs are:
1
11
111
1.1
11.11
111.11
I have tried with the following regex ^([^-]\d{0,2}(.\d{1,2})?)$ which fulfills my requirements except it's accepting 0 which I don't want. How I can modify my regex so only 0's do not get matched?
Thanks For Help

Try
^(?=.*[1-9])\d{1,3}(?:\.\d\d?)?$
It should do it for you.
It starts with a positive look-ahead to make sure there's a digit other than 0 present.
Then it matches 1-3 digits, optionally followed by a . and 1-2 digits.
Your regex101 updated.

([0-9]){1,3}(\.[0-9]{1,2})? is the expression you are searching for.
([0-9]){1,3} = any number sequence with a length from 1 up to 3
(\.[0-9]{1,2})? = "?" maybe there is a float tail
(\.[0-9]{1,2}) = float tail must start with a dot and decimal numbers have to be up to 2
There is a way to except all zero sequences but it will waste your time for no reason, as you can simply check it with if myNum > 0.
It will work for negative values also, but this regex excludes them too.

^[1-9][0-9]*(\.[0-9]+)?$|^0\.[0-9]+$
This will work for you. It accepts all valid positive decimal numbers excluding 0.

Regular Expression: Help Matching a number less than 24

so I'm making this regular expression to verify some text boxes on a website that I'm designing for an internship.
The problem is that I'm not so keen on regular expressions, and I'm close to having a working one that matches a number between 0-24 and no more than two decimal places.
This is what I have so far. The pattern is also matching any string; such as, "a" or "az".
var pattern = "^([0-9]{0,2}?.?[0-9]{0,2}|1[0-9].?[0-9]{0,2}|2[0-4].?[0-9]{0,2})$";

To get a number between 0 and 24 (24 excluded) with optional up to two decimal places:
^(\d|1\d|2[0-3])(\.\d{1,2})?$
The decimal part:
\. - match the decimal dot
\d{1,2} - one or two digits
()? - makes it optional
The whole part:
\d - numbers 0-9
1\d - numbers 10-19
2[0-3] - numbers 20-23
(x|y|z) - one of x, y or z
As for the "why is my version matching things like "a" and "az" part" - it's a little complex, but it basically boils down to you using dots (like .?). In regex, a dot means "any one character". To make it match a literal dot, you need to escape it with a slash just like I did.
Minor remark: If you want optional leading zero for single digit numbers, replace 1\d with [01]\d. If you want mandatory leading zero for single digit numbers, replace \d|1\d with [01]\d. If you don't want leading zeroes, leave it as it is.

Assuming you do not want 05 or 5.50
^((?:[0-9]|1[0-9]|2[0-3])(?:\.(?:[1-9]|[0-9][1-9]))?)$
You can try it here

The following is a quick attempt to match a floating point number from 0 to 24.99 with up to two non-zero digits
^(([0-9])|([01][0-9])|(2[0-4]))(\.[0-9]{1,2})?$
I think it might be easier to use math to do this though...

You can see the explanation of the entire regex as well as test it out here. I have also added a few test cases.
^(\d|[01]\d|2[0-3])(\.\d{1,2})?$
Test cases:
Valid:
22
1.29
2.99
9.99
13.24
17.38
20.01
02.15
15.35
23.56
1.1
Invalid:
24.29
235.215
21.256

To get a integer number between 1 and 23: ^([1-9]|1[0-9]|2[0-3])$

Regex to check amount is greator then one

I have a regex
^(?=.*[1-9])\\d{0,5}(?:\\.\\d{0,2})?$
to check amount should be greater then 0 and it can contain maximum five digit before decimal and optional decimal and 2 digits after decimal.
Here (?=.*[1-9]) is to check there should be latest one occurrence of any digit from (1-9) in the string.
But I want modify it to check amount greater then one(1), so I want (?=.*[1-9]) to check only till the occurrence of the decimal point i.e. 0.1 it should return false.
Other condition should also fulfill.
Note : the count of digits before decimal is not fix, it will very from 1 to 5, so we can't modify it to (?=.{0,5}[1-9])

You can fix it by using this negation based regex:
^(?=[^.]*[1-9])\\d{0,5}(?:\\.\\d{0,2})?$
RegEx Demo
[^.]* before [1-9] will match any character except decimal point thus not allowing 0.45 as valid number.

What regex for jQuery satisfies these conditions?

I have a field for which can have:
Up to potentially 2 decimals places
Up to potentially 6 non-decimal places
No more than 8 digits altogether (the max 2 decimals plus max 6 non-decimals)
Be a positive number
So correct inputs would be range from 0.01 to 999999.99, and trailing zeroes isn't an issue, so 4.00 is just as fine as 4.

Try this pattern:
^[0-9]{1,6}(?:\.[0-9]{1,2}0*)?$
If you want to allow leading and trailing whitespace, add \s* to the beginning and the end of the pattern, right after ^ and right before $.
That said, this task is something you might want to accomplish without regex. Why don't you just read the value of the input, parse it and then simply perform a numeric validation? You could even round the input to two decimal places.

You could try something like so:
Up to potentially 2 decimals places: (\.\d{1,2})? - This will match a decimal point followed by a minimum of 1, and a maximum of 2 digits. This is optional.
Up to potentially 6 non-decimal places: \d{1,6} - This will match a minimum of 1 digit and a maximum of 6 digits.
No more than 8 digits altogether (the max 2 decimals plus max 6 non-decimals): You can combing the two above to get this: \d{1,6}(\.\d{1,2})?.
Be a positive number: Change the above to this: ^\d{1,6}(\.\d{1,2})?$. This should make sure that any number you pass to it, does not start with a negative sign. The ^ and $ anchors instruct the regex engine to start matching at the beginning of the string and complete the matching at the end. This should allow you to be sure that the string you are matching is indeed a number.
That being said, you should really be doing numerical range checks using the appropriate mathematical operations which your language (in this case JavaScript) provides. A small change in the numerical range you are after will most likely bring a large change in your regular expression.

This might validate it
# /^(?=.*[1-9].*$)(?=[.]?(?:\d[.]?){1,8}$)(?=\d{0,6}(?:[.]\d{0,2})?$)/
^
(?= # must be a positive number
.* [1-9] .* $
)
(?=
[.]?
(?: # 1 to 8 digits
\d
[.]?
){1,8}
$
)
(?=
\d{0,6} # 0 to 6 non-decimal places
(?:
[.] # 0 to 2 decimal places
\d{0,2}
)?
$
)