CIDR (Classless Inter-Domain Routing, pronounced "kidder" or "cider" - add your own local variant to the comments!) is a system of defining the network part of an IP address (usually people think of this as a subnet mask). The reason it's "classless" is that it allows a way to break IP networks down more flexibly than their base class.
When IP networks were first defined, IPs had classes based on their binary prefix:
Class Binary Prefix Range Network Bits
A 0* 0.0.0.0-127.255.255.255 8
B 10* 128.0.0.0-191.255.255.255 16
C 110* 192.0.0.0-223.255.255.255 24
D 1110* 224.0.0.0-239.255.255.255
E 1111* 240.0.0.0-255.255.255.255
(Note that this is the source of people referring to a /24 as a "class C", although that's not a strictly true comparison because a class C needed to have a specific prefix)
These binary prefixes were used for routing large chunks of IP space around. This was inefficient because it resulted in large blocks being assigned to organizations who didn't necessarily need them, and also because Class Cs could only be assigned in 24 bit increments, meaning that routing tables could get unnecessarily large as multiple Class Cs were routed to the same location.
CIDR was defined to allow variable length subnet masks (VLSM) to be applied to networks. As the name applies, address groups, or networks, can be broken down into groups that have no direct relationship to the natural "class" they belong to.
The basic premise of VLSM is to provide the count of the number of network bits in a network. Since an IPv4 address is a 32-bit integer, the VLSM will always be between 0 and 32 (although I'm not sure in what instance you might have a 0-length mask).
The easiest way to start calculating VLSM/CIDR in your head is to understand the "natural" 8-bit boundaries:
CIDR Dotted Quad
/8 255.0.0.0
/16 255.255.0.0
/24 255.255.255.0
/32 255.255.255.255
(By the way, it's perfectly legal, and fairly common in ACLs, to use a /32 mask. It simply means that you are referring to a single IP)
Once you grasp those, it's simple binary arithmetic to move up or down to get number of hosts. For instance, if a /24 has 256 IPs (let's leave off network and broadcast addresses for now, that's a different networking theory question), increasing the subnet by one bit (to /25) will reduce the host space by one bit (to 7), meaning there will be 128 IPs.
Here's a table of the last octet. This table can be shifted to any octet to get the dotted quad equivalent.
CIDR Dotted Quad
/24 255.255.255.0
/25 255.255.255.128
/26 255.255.255.192
/27 255.255.255.224
/28 255.255.255.240
/29 255.255.255.248
/30 255.255.255.252
/31 255.255.255.254
/32 255.255.255.255
As an example of shifting these to another octet, /18 (which is /26 minus 8 bits, so shifted an octet) would be 255.255.192.0.
Let me show my working here...
You need a minimal number of CIDR blocks to cover:
0.0.0.0-9.255.255.25511.0.0.0-172.15.255.255172.32.0.0-192.167.255.255192.169.0.0-223.255.255.255
To turn these ranges into minimal CIDR blocks, you can just use netmask (the swiss army knife of addressing), like so:
$ netmask -c 0.0.0.0:9.255.255.255
0.0.0.0/5
8.0.0.0/7
$ netmask -c 11.0.0.0:172.15.255.255
11.0.0.0/8
12.0.0.0/6
16.0.0.0/4
32.0.0.0/3
64.0.0.0/2
128.0.0.0/3
160.0.0.0/5
168.0.0.0/6
172.0.0.0/12
$ netmask -c 172.32.0.0:192.167.255.255
172.32.0.0/11
172.64.0.0/10
172.128.0.0/9
173.0.0.0/8
174.0.0.0/7
176.0.0.0/4
192.0.0.0/9
192.128.0.0/11
192.160.0.0/13
$ netmask -c 192.169.0.0:223.255.255.255
192.169.0.0/16
192.170.0.0/15
192.172.0.0/14
192.176.0.0/12
192.192.0.0/10
193.0.0.0/8
194.0.0.0/7
196.0.0.0/6
200.0.0.0/5
208.0.0.0/4
Hey presto, Bob's your Auntie's live-in lover.
Best Answer
It sounds like you want something close to the buddy allocator, to borrow a page (ha ha) from memory management.
Step 1: Transform the range you have into a series of CIDR blocks that are as large as possible without crossing the range boundary or overlapping with another block.
Step 2: Given the allocation you're trying to fit, find the smallest possible block that will fit it. Ideally this will match it exactly, but if not, you will split up the smallest block you did find (potentially recursively) until you're at the right size block.
My wording isn't particularly elegant here but I hope you get the idea.