Get min and max integer value containing X number of digits

user_6236042 0
Viewed 883

What would be the best way to generate the lowest and highest integer values which contain x number of digits?

For example:

  • x = 1: Min = 0, Max = 9
  • x = 2: Min = 10, Max = 99
  • x = 3: Min = 100, Max = 999
  • x = 4: Min = 1000, Max = 9999

I feel like this should be a really easy thing to accomplish but I'm struggling to get my head around the math behind it.

Here's what I've got so far for generating the max value (based on this answer):

public static int MaxIntWithXDigits(this int x)
{
    if (x == 0) throw new ArgumentException(nameof(x), "An integer cannot contain zero digits.");

    try
    {
        return Convert.ToInt32(Math.Pow(10, x) -1);
    }
    catch 
    {
        throw new InvalidOperationException($"A number with {x} digits cannot be represented as an integer.");
    }
}

If anyone can help with generating the min value or suggest improvements on the code above I'd appreciate it.

Edit

I'm almost there - this seems to work for everything except when x = 1 (and min value expected as 0)

public static int MinIntWithXDigits(this int x)
{
    if (x == 0) throw new ArgumentException(nameof(x), "An integer cannot contain zero digits.");

    x -= 1;

    try
    {
        return Convert.ToInt32(Math.Pow(10, x));
    }
    catch
    {
        throw new InvalidOperationException($"A number with {x} digits cannot be represented as an integer.");
    }
}
numbers number-formatting math c#
2 Answers

Fox any x>1, the min value would be 10x-1. E.g.:

  • If x = 2, min=102-1 = 101 = 10
  • If x = 3, min=103-1 = 102 = 100
  • If x = 4, min=104-1 = 103 = 1000

For x=1, since it's the only value that is not a one followed by a series of zeroes, you'll need special treatment.

public static int MinIntWithXDigits(this int x)
{
    if (x == 0) 
    {
        throw new ArgumentException(nameof(x), "An integer cannot contain zero digits.");
    }

    if (x == 1) {
        return 0;
    }

    try
    {
        return Convert.ToInt32(Math.Pow(10, x - 1));
    }
    catch 
    {
        throw new InvalidOperationException($"A number with {x} digits cannot be represented as an integer.");
    }
}

Side note:
If the result were restricted to positive integers instead of non-negative integers, the smallest integer with one digit would be 1, and the general formula would have applied for this case too.

user_24227760

You can try something like this:

// let's return min and max in one go as a value tuple
public static (int min, int max) MaxIntWithXDigits(this int x) {
  if (x <= 0 || x > 9)
    throw new ArgumentOutOfRangeException(nameof(x));

  int min = (int)Math.Pow(10, x - 1); 

  return (min == 1 ? 0 : min, min * 10 - 1); 
}

Demo:

var result = Enumerable
  .Range(1, 9)
  .Select(x => $"{x} : {MaxIntWithXDigits(x).min} .. {MaxIntWithXDigits(x).max}"); 

Console.Write(string.Join(Environment.NewLine, result));

Outcome:

 1 : 0 .. 9
 2 : 10 .. 99
 3 : 100 .. 999
 4 : 1000 .. 9999
 5 : 10000 .. 99999
 6 : 100000 .. 999999
 7 : 1000000 .. 9999999
 8 : 10000000 .. 99999999
 9 : 100000000 .. 999999999
user_23194070
Related