Recursive Function

Question

I have absolutely no idea, so if someone can point me in the right direction, it'd be greatly appreciated.

I want to have something like

<?php
function square($num) {
// something
}

name('{3}'); // have this return 9
name('{6}'); // have this return 36
name('{{{2}}}'); // have this return 256
name('{9}{12}'); // have this return 81144
name('{{5}}'); // have this return 125
name('adscdc{4}{{3}}'); // have this return adscdc1681
?>

Does anyone have any idea how this can be done? Thanks in advance :) So far, I have:

<?php
function square($text) {
    $parts = explode('{', $text);
    foreach($parts as $part) {
        $piece = explode('}', $part);
        $text = str_replace('{' . $piece[0] . '}', pow($piece[0], 2), $text);
    }
    return $text;
}
echo square('aasd{3}');
?>

Answer 1

I think {{5}} should be 625, right?

Anyway, try something like this:

<?php

  function name ($str) { 
    while (1) {
      preg_match('/{(\d+)}/', $str, $matches);
      if (count($matches)<2) return $str;
      $str=str_replace($matches[0], $matches[1]*$matches[1], $str);
    }
  }

  echo "\n<pre>\n".
       name('{3}'). // have this return 9
       "\n".
       name('{6}'). // have this return 36
       "\n".
       name('{{{2}}}'). // have this return 256
       "\n".
       name('{9}{12}'). // have this return 81144
       "\n".
       name('{{5}}'). // have this return 625
       "\n".
       name('adscdc{4}{{3}}'). // have this return adscdc1681
       "\n</pre>\n";

?>

...running that gave me these results:

9
36
256
81144
625
adscdc1681

Answer 2

You'll probably need to parse the string. Keep reading characters till you reach an open brace, then on each open brace increment a counter. When you get to a number raise it to the power of the counter. Then decrement for each closing brace, and if the braces don't match throw an exception.

Answer 3

I thought this problem is interesting. But I already see some good answers in PHP, so just for the porpuse of training myself I implemented a solution in Python. If you are interested, you can have a look here:

>>> import re
>>> test = [('5','5'),('{3}','9'),('{6}','36'),('{{{2}}}','256'),('{9}{12}','81144'),('adscdc{4}{{3}}','adscdc1681')]
>>> def eval(txt):
...   replace = lambda t: re.sub('{(\d+)}',lambda match: str(int(match.group(1)) * int(match.group(1))),t)
...   while(re.search('[{}]',txt) != None):
...     txt = replace(txt)
...   return txt
... 
>>> for t in test:
...   print (t[0],t[1],eval(t[0]) == t[1])
... 
('5', '5', True)
('{3}', '9', True)
('{6}', '36', True)
('{{{2}}}', '256', True)
('{9}{12}', '81144', True)
('adscdc{4}{{3}}', 'adscdc1681', True)

It is also interesting to see, that python while beeing a very strong language for many solutions, often produces pretty ugly code, when handling regexes.

(This post is not intended as answer to the posted problem, because there are already enough good answers. I just share it for the interested eyes.)

Answer 4

Looks simple. When you detect a motive like a number inside curly brackets it should be replaced by the square of the number. If no replacement where done you are finished. If some replacement where done you do it again (because what was just replaced may be now inside curly brackets) and so on.

The first part (replacement) can be done using regex, the second part can be done either recursively either or iteratively.

Below some code snippet that should help you understand the details (not the full answer, but not far). The goal of the exercice seems to be to help you understand preg_replace() parameters.

<?php
$count = 0;
echo preg_replace('/[{](\d+)[}]/e', '$1*$1', '{{{2}}}', -1, $count);
echo "\n";
echo "$count replacement done\n";
?>

As others proposed full solutions, here his mine:

<?php

function square($str){
    $count = 0;
    do {
        $str = preg_replace('/[{](\d+)[}]/e', '$1*$1', $str, -1, $count);
    } while ($count);
    return $str;
}

echo square('{3}')."\n"; // have this return 9
echo square('{6}')."\n"; // have this return 36
echo square('{{{2}}}')."\n"; // have this return 256
echo square('{9}{12}')."\n"; // have this return 81144
echo square('{{5}}')."\n"; // have this return 125
echo square('adscdc{4}{{3}}')."\n"; // have this return adscdc1681

?>

If your are preoccupied with compatibility issues (because hardened php installation may forbid use of /e) just use preg_replace_callback instead of preg_replace like below (use anonymous function available as of PHP 5.2.3, for older php version, you can use create_function()).

function square($str){
    $count = 0;
    do {
        $str = preg_replace_callback('/[{](\d+)[}]/',
                    function($m) {return $m[1]*$m[1];},
                    $str, -1, $count);
    } while ($count);
    return $str;
}

For curious readers, as someone else suggested a python version, below is a possible perl equivalent:

#!/usr/bin/perl

my @tests = ('{3}','{6}','{{{2}}}','{9}{12}','{{5}}', 'adscdc{4}{{3}}'); 

sub square {
    my $str = pop;
    while ($str =~ s/[{](\d+)[}]/$1*$1/e) {};
    return $str;
}

for my $str (@tests){
    print "$str --> ".square($str)."\n" ;
} 

There security mechanisms in Perl to avoid injections because of evil user inputs different than blindly rejecting all evals. For those interested you can have a look here.

And two other shorter python versions, recursive:

import re
test = ['5','{3}','{6}','{{{2}}}','{9}{12}','adscdc{4}{{3}}']

def square(txt):
   txt2 = re.sub('{(\d+)}',lambda m: str(int(m.group(1)) ** 2) , txt)
   if txt2 == txt:
        return txt
   return square(txt2)

for x in test:
    print("%s --> %s" % (x, square(x)))

and non recursive

import re
test = ['5','{3}','{6}','{{{2}}}','{9}{12}','adscdc{4}{{3}}']

def square(txt):
    oldtxt = None
    while oldtxt != txt:
        oldtxt = txt
        txt = re.sub('{(\d+)}',lambda m: str(int(m.group(1)) ** 2) , oldtxt)
    return txt

for x in test:
    print("%s --> %s" % (x, square(x)))

Answer 5

This getting {} brackets and for each bracket get decimal in her and power to number of bracket nested, output was concated to string in place of parsed brackets without any separation character.

Answer 6

This necessarily needn't be a recursive function. Apart from the core logic others mentioned, you need to make sure if the input string is valid. For instance examples like:

name('{{9}{{{{{1}');
name('{abbc}');
name('{}');