如何检查两个字符串是否具有相同的开头？

Question

Considering I have one-dimensional ordered array of strings:

$arr = [
    'Something else',
    'This is option: one',
    'This is option: two',
    'This is option: 😜',
    'This is second option: 2',
    'This is second option: 3'
];

I would like to turn it into two-dimensional array, having the common beginning as the key. For example:

$target = [
    'Something else',
    'This is option:' => [
        'one',
        'two',
        '😜'
    ],
    'This is second option:' => [
        '2',
        '3'
    ]
];

It sounds simple, but I have gone completely blank.

function convertArr(array $src): array {
    $prevString = null;
    $newArray = [];
    foreach ($src as $string) {
        if ($prevString) {
            // stuck here
        }
        $prevString = $string;
    }
    return $newArray;
}

Pre-made fiddle: https://3v4l.org/eqGDc

How can I check if two strings start with the same words, without having to loop on each letter?

As of now I have written this overly-complicated function, but I wonder if there is a simpler way:

function convertArr(array $src): array {
    $prevString = null;
    $newArray = [];

    $size = count($src);
    for ($i = 0; $i < $size; $i++) {
        if (!$prevString || strpos($src[$i], $prevString) !== 0) {
            if ($i == $size - 1) {
                $newArray[] = $src[$i];
                break;
            }
            $nowWords = explode(' ', $src[$i]);
            $nextWords = explode(' ', $src[$i + 1]);
            foreach ($nowWords as $k => $v) {
                if ($v != $nextWords[$k]) {
                    break;
                }
            }
            if ($k) {
                $prevString = implode(' ', array_splice($nowWords, 0, $k));
                $newArray[$prevString][] = implode(' ', $nowWords);
            }
        } else {
            $newArray[$prevString][] = trim(substr($src[$i], strlen($prevString)));
        }
    }
    return $newArray;
}

Answer 1

I haven't got a complete solution, but maybe you can use this as a starting point: The following gets you the longest common starting sequence for the strings in an array of length 2:

var s=["This is option: one","This is option: two"]; 
var same=s.join('|').match(/(.*)(.*?)\|\1.*/)[1];
// same="This is option: "

In same you will find the longest possible beginning of the two strings in array s . I achieve this by using a regular expression with a greedy and a non-greedy wildcard group and forcing the first group to be repeated.

You could apply this method on slice() -d short arrays of your original sorted input array and monitor whether same stays the same for a number of these sub-arrays. You can then perform your intended grouping operation on sections with the same same .

[[ Sorry, I just realized I coded this in JavaScript and you wanted PHP - but the idea is so simple you can translate that easily into PHP yourself. ]]

Edit

When looking at the question and expected result again it seems to me, that what the OP really wants is to combine elements with similar parts before the colon (:) into a common sub-array. This can be done with the following code:

$arr = [
    'Is there anything new and',
    'Something old',
    'This is option: one',
    'This is option: two',
    'This is option: 😜',
    'This is second option: 2',
    'This is second option: 3',
    'Abc: def',
    'Abc: ghi',
    'the same line',
    'the same words'
];
foreach($arr as $v) {
 $t=array_reverse(explode(':',$v));
 $target[isset($t[1])?trim($t[1]):0][]=trim($t[0]);
}
print_r($target)

output:

Array
(
    [0] => Array
        (
            [0] => Is there anything new and
            [1] => Something old
            [2] => the same line
            [3] => the same words
        )

    [This is option] => Array
        (
            [0] => one
            [1] => two
            [2] => 😜
        )

    [This is second option] => Array
        (
            [0] => 2
            [1] => 3
        )

    [Abc] => Array
        (
            [0] => def
            [1] => ghi
        )

)

See a demo here https://rextester.com/JMB6676

Answer 2

This might do the job:

function convertArray(array $values): array
{
    $newArray = [];
    foreach ($values as $value) {
        if (stripos($value, ':') !== false) {
            $key = strtok($value, ':');
            $newArray[$key][] = trim(substr($value, stripos($value, ':') + 1));
        }
    }

    return $newArray;
}

Essentially, based on the format of your array of strings, as long as each string only has one ":" character followed by the option value, this should work well enough.

I'm sure there will be a more advanced and more fail-safe solution but this may be a start.