PHP字符串和数组数组

Question

I'm writing a program in PHP (as it will accompany web code for a mathematics grading system) and I need to create an array of strings and arrays. Specifically, I want to convert something like

((4)+((5)*(pi)))-((9)*(sqrt(3)))

to

[["4", ["5", "pi", "*"], "+"], ["9", ["3", "sqrt"], "*"], "-"]

which is an array formatting of reverse-polish notation. With this I would evaluate for commutativity accross operators to compare the correct, stored answer to a student's answer. However, I'm unable to do this in PHP with multidimensional arrays due to the unevenness of the rows.

If there's a way to do this using strings, that would be even more helpful (as I plan to store results in an SQL database), but for that I could probably use serialize() .

Thanks for any help.

EDIT : I think I got it to work. Using the short array notation seemed to cause the problem. The old array() notation seems to function properly, like so:

array(array("4", array("5", "pi", "*"), "+"), array("9", array("3", "sqrt"), "*"), "-")

and serialized notation (for storing in a database) is:

a:3:{i:0;a:3:{i:0;s:1:"4";i:1;a:3:{i:0;s:1:"5";i:1;s:2:"pi";i:2;s:1:"*";}i:2;s:1:"+";}i:1;a:3:{i:0;s:1:"9";i:1;a:2:{i:0;s:1:"3";i:1;s:4:"sqrt";}i:2;s:1:"*";}i:2;s:1:"-";}.

Answer 1

I don't see what's the issue with constructing this array dynamically. For instance, this works (not postfix):

$test_array = array(
                    array(
                        "4",
                        array(
                            "5", 
                            "pi", 
                            "*"
                        ),
                        "+"
                    ),
                    array(
                        "9", 
                        array(
                            "3",
                            "sqrt"
                        ),
                        "*"
                    ),
                    "-"
            );

var_dump($test_array);

So making this dynamically using your algorithm should behave in similar manner to doing this (of course the order for adding the element depends on your algorithm):

$test_array2 = array();
$test_array2[] = array();
$test_array2[] = array();
$test_array2[] = "-";
$test_array2[1][] = "9";
$test_array2[1][] = array();
$test_array2[1][1][] = "3";
$test_array2[1][1][] = "sqrt";
$test_array2[1][] = "*";
$test_array2[0][] = "4";
$test_array2[0][] = array();
$test_array2[0][1][] = "5";
$test_array2[0][1][] = "pi";
$test_array2[0][1][] = "*";
$test_array2[0][] = "+";

var_dump($test_array2);

Both examples above have the same output.

Answer 2

Here is a function that will do the conversion from string to nested array:

function convert($string) {
    function nest(&$base) {
        $result = [];
        while (($ch = array_shift($base)) !== null) {
            if ($ch === ')') break;
            $result[] = $ch === '(' ? nest($base) : $ch;
        }
        if (count($result) < 2) return reset($result);
        // Move operator to the end of the array:
        $result[] = array_splice($result, -2, 1)[0];
        return $result;
    }
    // split string into parts, where each bracket is a separate part
    $base = preg_split("/([()])/", $string, 0, PREG_SPLIT_DELIM_CAPTURE 
                                             + PREG_SPLIT_NO_EMPTY);
    // recursively build nested postfix structure
    return nest($base);
}

You would call it like this:

$result = convert($string);

For the sample input provided in the question, the output is:

array (
  array (
    '4',
    array (
      '5',
      'pi',
      '*',
    ),
    '+',
  ),
  array (
    '9',
    array (
      '3',
      'sqrt',
    ),
    '*',
  ),
  '-',
)

Note that the function sqrt is also separated as a postfix function.

See it run on eval.in .

Answer 3

For versatility and universality, you could also use an associative array, with, as indexes, their roles, as in one of {operand1, operand2, and operator}. Indeed, any math expression you stated above could be of the pattern: "operand1 operator operand2", however complex they are in the end.

Example:

5.pi would be

array('op1'=>5, 'op'=>'*', 'opd2'=>'pi');

sqrt(3) would be

array('op1' => 3, 'op' => 'sqrt', 'opd2' => null); // since sqrt is a unary function

and so on...

This way the model would be expandable, you would benefit from the array functions family concerning indexes, without worrying about the orders of the array members, and the parser would be, IMHO, a lot simpler to write, and be read by a human, at least.