More complicated range generation - php

Question

Producing a range with PHP is easy when the range is something like 1 to 100 or A to Z. But I need to be able to produce ranges like 101A to 101Z or A1 to A100.
I thought that maybe PHP has a function to compare two strings, strip what's common between them and return the rest to form the range boundaries. However I can not find such a function. How would I achieve this?
EDIT: I don't have control over the format, I can only set the guidelines. The end user determines the pattern by entering something like A1-A100 into an input field.

Answer 1

101A to 101Z is like "101" + range("A", "Z")
and
A1 to A100 is like "A" + range(1, 100)
If you're looking for A1 to Z100 that's when things get a bit more complicated.
You can look at the way functions like base converters work, like dechex and base64_encode
If you're converting from the decimal system to your own notation you can do thing kind of conversion.
1 => A1
2 => A2
101 => B1
102 => B2
2601? => Z1
2700? => Z100
This just describes the outline. If you want code you'll have to make your question more clear.
Arbitrary ranges is .. very hard. I don't know of a solution. A1-A100 has a clear solution, but what about A1-100Z, how do you even begin? What about small-large or Boston-New York?

Answer 2

You can try with:
function rangeFix($from, $to, $prefix = null, $suffix = null) {
return array_map(function($item) use ($prefix, $suffix){
return $prefix . $item . $suffix;
}, range($from, $to));
}
rangeFix(0, 10, 'A', 'Z');
Output:
array (size=11)
0 => string 'A0Z' (length=3)
1 => string 'A1Z' (length=3)
2 => string 'A2Z' (length=3)
3 => string 'A3Z' (length=3)
4 => string 'A4Z' (length=3)
5 => string 'A5Z' (length=3)
6 => string 'A6Z' (length=3)
7 => string 'A7Z' (length=3)
8 => string 'A8Z' (length=3)
9 => string 'A9Z' (length=3)
10 => string 'A10Z' (length=4)
or:
rangeFix('A', 'Z', 101);
Output:
array (size=26)
0 => string '101A' (length=4)
1 => string '101B' (length=4)
2 => string '101C' (length=4)
3 => string '101D' (length=4)
4 => string '101E' (length=4)
5 => string '101F' (length=4)
6 => string '101G' (length=4)
7 => string '101H' (length=4)
8 => string '101I' (length=4)
9 => string '101J' (length=4)
10 => string '101K' (length=4)
11 => string '101L' (length=4)
12 => string '101M' (length=4)
13 => string '101N' (length=4)
14 => string '101O' (length=4)
15 => string '101P' (length=4)
16 => string '101Q' (length=4)
17 => string '101R' (length=4)
18 => string '101S' (length=4)
19 => string '101T' (length=4)
20 => string '101U' (length=4)
21 => string '101V' (length=4)
22 => string '101W' (length=4)
23 => string '101X' (length=4)
24 => string '101Y' (length=4)
25 => string '101Z' (length=4)

Answer 3

This is my own, not so elegant solution. It works with the following logic:
Range boundaries have two parts, of which the other is digit and the other non-digit, such as A1 or 1A. One-part string work too, such as A or 1. I did not test with strings such as A1B where there are more than two parts. The script probably fails there.
$s1 = '101A';
$s2 = '101Z';
$s1_d = preg_split('/\d+/', $s1);
$s1_D = preg_split('/\D+/', $s1);
$s2_d = preg_split('/\d+/', $s2);
$s2_D = preg_split('/\D+/', $s2);
if($s1_d[0] == '') $s1_d[0] = $s1_D[0];
else $s1_d[1] = $s1_D[1];
$s1 = $s1_d;
if($s2_d[0] == '') $s2_d[0] = $s2_D[0];
else $s2_d[1] = $s2_D[1];
$s2 = $s2_d;
$prefix = false;
$postfix = false;
if($s1[0] == $s2[1]) die(); // Can't do it.
if($s1[0] == $s2[0]) {
$prefix = $s1[0];
$start = $s1[1];
$end = $s2[1];
}
else {
$postfix = $s1[1];
$start = $s1[0];
$end = $s2[0];
}
$range = range($start, $end);
foreach($range as &$r) {
$r = $prefix . $r . $postfix;
}
var_dump($range);