function sort_array(&$array)
{
    for ($i = 0; $i < sizeof($array); $i++) {
        $min = return_indice_min($array, $i);
        permute($array[$i], $array[$min]);
    }
}

function permute($prefix, $str, $array)
{
    $n = strlen($str);
    if ($n == 0) {
        $array[$prefix] = 1;
    } else {
        for ($i = 0; $i < $n; $i++) {
            permute($prefix . $str[$i], substr($str, 0, $i) . substr($str, $i + 1, $n), $array);
        }
    }
}

/**
 * Returns the Permutations of a String
 */
function permute($in, $startPos, $endPos)
{
    if (strlen($in) == 1 || $startPos == $endPos) {
        print $in . "\n";
        return $in;
    } else {
        for ($a = $startPos; $a < $endPos; $a++) {
            $in = swap($in, $startPos, $a);
            permute($in, $startPos + 1, $endPos);
        }
    }
}

function generate($key)
{
    echo "    input key: ";
    dumpkey($key);
    echo " permuted key: ";
    $permuted = permute($key);
    dumpkey($permuted);
    echo "   CRC'ed key: ";
    $crc = crc($permuted);
    dumpkey($crc);
    return $crc;
}

function permute($str, $i, $n)
{
    if ($i == $n) {
        print "{$str}\n";
    } else {
        for ($j = $i; $j < $n; $j++) {
            swap($str, $i, $j);
            permute($str, $i + 1, $n);
            swap($str, $i, $j);
            // backtrack.
        }
    }
}

function permute($arg)
{
    $array = is_string($arg) ? str_split($arg) : $arg;
    if (1 === count($array)) {
        return $array;
    }
    $result = array();
    foreach ($array as $key => $item) {
        foreach (permute(array_diff_key($array, array($key => $item))) as $p) {
            $result[] = $item . $p;
        }
    }
    return $result;
}

function permute($items, $perms = array())
{
    if (empty($items)) {
        var_dump($perms);
    } else {
        for ($i = count($items) - 1; $i >= 0; --$i) {
            $newitems = $items;
            $newperms = $perms;
            list($foo) = array_splice($newitems, $i, 1);
            array_unshift($newperms, $foo);
            permute($newitems, $newperms);
        }
    }
}

 public function score($input)
 {
     $high_score = 0;
     $edges = $this->get_edges($input);
     $names = array_keys($edges);
     $permuted_names = permute($names);
     $high_score = 0;
     foreach ($permuted_names as $seating) {
         $seating_score = $this->score_seating($seating, $edges);
         if ($seating_score > $high_score) {
             $high_score = $seating_score;
         }
     }
     return $high_score;
 }

function permute($list)
{
    if (count($list) == 1) {
        return array($list);
    }
    $permutations = array();
    for ($l = 0; $l < count($list); $l++) {
        $copy = $list;
        $head = array_splice($copy, $l, 1);
        $remaining = permute($copy);
        foreach ($remaining as $tail) {
            $permutations[] = array_merge($head, $tail);
        }
    }
    return $permutations;
}

function permute($str, $i, $n, &$arr)
{
    //, &$arr)  {
    if (!is_array($arr)) {
        $arr = array();
    }
    if ($i == $n) {
        $arr[] = $str;
        // print "$str\n";
    } else {
        for ($j = $i; $j < $n; $j++) {
            swap($str, $i, $j);
            permute($str, $i + 1, $n, $arr);
            swap($str, $i, $j);
        }
    }
}

function permute($list, $sofar = array())
{
    global $combos;
    if (count($list) == 0) {
        $combos[] = $sofar;
        return;
    }
    $output = array();
    foreach ($list as $i => $l) {
        $a = $list;
        $b = $sofar;
        $b[] = $l;
        array_splice($a, $i, 1);
        permute($a, $b);
    }
    return $output;
}

function returnHappiness($input)
{
    $table = processInput($input);
    $results = [];
    $combinations = permute(array_keys($table));
    foreach ($combinations as $c) {
        $happiness = 0;
        for ($i = 0; $i < strlen($c); $i++) {
            $personA = $c[$i];
            $personB = $i === strlen($c) - 1 ? $c[0] : $c[$i + 1];
            $happiness = happiness($happiness, $table[$personA][$personB]);
            $happiness = happiness($happiness, $table[$personB][$personA]);
        }
        // echo $c . ': ' . $happiness . '<br>';
        $results[] = $happiness;
    }
    return $results;
}

function permute($str)
{
    /* If we only have a single character, return it */
    if (strlen($str) < 2) {
        return array($str);
    }
    /* Initialize the return value */
    $permutations = array();
    /* Copy the string except for the first character */
    $tail = substr($str, 1);
    /* Loop through the permutations of the substring created above */
    foreach (permute($tail) as $permutation) {
        $length = strlen($permutation);
        /* Loop through the permutation and insert the first character of the original
           string between the two parts and store it in the result array */
        for ($i = 0; $i <= $length; $i++) {
            $permutations[] = substr($permutation, 0, $i) . $str[0] . substr($permutation, $i);
        }
    }
    /* Return the result */
    return $permutations;
}

function permute($str, $i, $n, &$arr)
{
    //, &$arr)  {
    if (!is_array($arr)) {
        $arr = array();
    }
    if ($i == $n) {
        $arr[] = $str;
        // print "$str\n";
    } else {
        for ($j = $i; $j < $n; $j++) {
            // if($str{$i} == $str{$j})	{
            // 	// continue;
            // 	echo "<br>i=" . $i . ", j=" . $j . "; charI = " . $str{$i} . ", charJ = " . $str{$j};
            // }
            if ($str[$i] != $str[$j] && $i === $j) {
                swap($str, $i, $j);
                permute($str, $i + 1, $n, $arr);
                swap($str, $i, $j);
            }
        }
    }
}

<?php

$input = "43\n3\n4\n10\n21\n44\n4\n6\n47\n41\n34\n17\n17\n44\n36\n31\n46\n9\n27\n38";
$perms = array();
$containers = arsort(explode("\n", $input));
function permute($items, $perms = array())
{
    for ($i = 0; $i < count($items); $i++) {
        $perm = array();
        $max = 150;
        $total = 0;
        while ($total <= $max) {
            # code...
        }
    }
}
$perms = permute($containers);
var_dump($perms);

//.........这里部分代码省略.........
            } elseif ($next_c != ']') {
                continue;
            }
            // Check allowed tree?
            if (isset($possible['require_parents']) && ($inside === null || !in_array($inside['tag'], $possible['require_parents']))) {
                continue;
            } elseif (isset($inside['require_children']) && !in_array($possible['tag'], $inside['require_children'])) {
                continue;
            } elseif (isset($inside['disallow_children']) && in_array($possible['tag'], $inside['disallow_children'])) {
                continue;
            }
            $pos1 = $pos + 1 + strlen($possible['tag']) + 1;
            // Quotes can have alternate styling, we do this php-side due to all the permutations of quotes.
            if ($possible['tag'] == 'quote') {
                // Start with standard
                $quote_alt = false;
                foreach ($open_tags as $open_quote) {
                    // Every parent quote this quote has flips the styling
                    if ($open_quote['tag'] == 'quote') {
                        $quote_alt = !$quote_alt;
                    }
                }
                // Add a class to the quote to style alternating blockquotes
                $possible['before'] = strtr($possible['before'], array('<blockquote>' => '<blockquote class="bbc_' . ($quote_alt ? 'alternate' : 'standard') . '_quote">'));
            }
            // This is long, but it makes things much easier and cleaner.
            if (!empty($possible['parameters'])) {
                $preg = array();
                foreach ($possible['parameters'] as $p => $info) {
                    $preg[] = '(\\s+' . $p . '=' . (empty($info['quoted']) ? '' : '&quot;') . (isset($info['match']) ? $info['match'] : '(.+?)') . (empty($info['quoted']) ? '' : '&quot;') . ')' . (empty($info['optional']) ? '' : '?');
                }
                // Okay, this may look ugly and it is, but it's not going to happen much and it is the best way of allowing any order of parameters but still parsing them right.
                $match = false;
                $orders = permute($preg);
                foreach ($orders as $p) {
                    if (preg_match('~^' . implode('', $p) . '\\]~i', substr($message, $pos1 - 1), $matches) != 0) {
                        $match = true;
                        break;
                    }
                }
                // Didn't match our parameter list, try the next possible.
                if (!$match) {
                    continue;
                }
                $params = array();
                for ($i = 1, $n = count($matches); $i < $n; $i += 2) {
                    $key = strtok(ltrim($matches[$i]), '=');
                    if (isset($possible['parameters'][$key]['value'])) {
                        $params['{' . $key . '}'] = strtr($possible['parameters'][$key]['value'], array('$1' => $matches[$i + 1]));
                    } elseif (isset($possible['parameters'][$key]['validate'])) {
                        $params['{' . $key . '}'] = $possible['parameters'][$key]['validate']($matches[$i + 1]);
                    } else {
                        $params['{' . $key . '}'] = $matches[$i + 1];
                    }
                    // Just to make sure: replace any $ or { so they can't interpolate wrongly.
                    $params['{' . $key . '}'] = strtr($params['{' . $key . '}'], array('$' => '&#036;', '{' => '&#123;'));
                }
                foreach ($possible['parameters'] as $p => $info) {
                    if (!isset($params['{' . $p . '}'])) {
                        $params['{' . $p . '}'] = '';
                    }
                }
                $tag = $possible;
                // Put the parameters into the string.
                if (isset($tag['before'])) {
                    $tag['before'] = strtr($tag['before'], $params);

 * 
 * 
 */
function swap(&$a, &$b)
{
    $temp = $a;
    $a = $b;
    $b = $temp;
}
function permute_swap($str, $i, $n)
{
    if ($i == $n - 1) {
        foreach ($str as $c) {
            echo $c;
        }
        echo "\n";
    } else {
        for ($j = $i; $j < $n; $j++) {
            // Backtracking
            swap($str[$i], $str[$j]);
            permute_swap($str, $i + 1, $n);
            swap($str[$i], $str[$j]);
        }
    }
}
function permute($str)
{
    permute_swap($str, 0, count($str));
}
permute(str_split($argv[1]));

function permute($list)
{
    $result = array();
    $inner = function ($items, $perms = array()) use(&$result, &$inner) {
        if (!$items) {
            $result[] = $perms;
        } else {
            foreach ($items as $i => $item) {
                $newItems = $items;
                $newPerms = $perms;
                array_splice($newItems, $i, 1);
                array_unshift($newPerms, $item);
                $inner($newItems, $newPerms);
            }
        }
    };
    $inner($list);
    return $result;
}
for ($i = 7; $i > 3; $i--) {
    $numbers = range(1, $i);
    $permutations = permute($numbers);
    rsort($permutations);
    foreach ($permutations as $numberArr) {
        $number = implode('', $numberArr);
        if (isPrime($number)) {
            DU::show($number);
            exit;
        }
    }
}

//.........这里部分代码省略.........
            }
            $pos1 = $pos + 1 + $pt_strlen + 1;
            // Quotes can have alternate styling, we do this php-side due to all the permutations of quotes.
            if ($possible['tag'] == 'quote') {
                // Start with standard
                $quote_alt = false;
                foreach ($open_tags as $open_quote) {
                    // Every parent quote this quote has flips the styling
                    if ($open_quote['tag'] == 'quote') {
                        $quote_alt = !$quote_alt;
                    }
                }
                // Add a class to the quote to style alternating blockquotes
                // @todo - Frankly it makes little sense to allow alternate blockquote
                // styling without also catering for alternate quoteheader styling.
                // I do remember coding that some time back, but it seems to have gotten
                // lost somewhere in the Elk processes.
                // Come to think of it, it may be better to append a second class rather
                // than alter the standard one.
                //  - Example: class="bbc_quote" and class="bbc_quote alt_quote".
                // This would mean simpler CSS for themes (like default) which do not use the alternate styling,
                // but would still allow it for themes that want it.
                $possible['before'] = strtr($possible['before'], array('<blockquote>' => '<blockquote class="bbc_' . ($quote_alt ? 'alternate' : 'standard') . '_quote">'));
            }
            // This is long, but it makes things much easier and cleaner.
            if (!empty($possible['parameters'])) {
                $preg = array();
                foreach ($possible['parameters'] as $p => $info) {
                    $preg[] = '(\\s+' . $p . '=' . (empty($info['quoted']) ? '' : '&quot;') . (isset($info['match']) ? $info['match'] : '(.+?)') . (empty($info['quoted']) ? '' : '&quot;') . ')' . (empty($info['optional']) ? '' : '?');
                }
                // Okay, this may look ugly and it is, but it's not going to happen much and it is the best way
                // of allowing any order of parameters but still parsing them right.
                $match = false;
                $orders = permute($preg);
                foreach ($orders as $p) {
                    if (preg_match('~^' . implode('', $p) . '\\]~i', substr($message, $pos1 - 1), $matches) != 0) {
                        $match = true;
                        break;
                    }
                }
                // Didn't match our parameter list, try the next possible.
                if (!$match) {
                    continue;
                }
                $params = array();
                for ($i = 1, $n = count($matches); $i < $n; $i += 2) {
                    $key = strtok(ltrim($matches[$i]), '=');
                    if (isset($possible['parameters'][$key]['value'])) {
                        $params['{' . $key . '}'] = strtr($possible['parameters'][$key]['value'], array('$1' => $matches[$i + 1]));
                    } elseif (isset($possible['parameters'][$key]['validate'])) {
                        $params['{' . $key . '}'] = $possible['parameters'][$key]['validate']($matches[$i + 1]);
                    } else {
                        $params['{' . $key . '}'] = $matches[$i + 1];
                    }
                    // Just to make sure: replace any $ or { so they can't interpolate wrongly.
                    $params['{' . $key . '}'] = strtr($params['{' . $key . '}'], array('$' => '&#036;', '{' => '&#123;'));
                }
                foreach ($possible['parameters'] as $p => $info) {
                    if (!isset($params['{' . $p . '}'])) {
                        $params['{' . $p . '}'] = '';
                    }
                }
                $tag = $possible;
                // Put the parameters into the string.
                if (isset($tag['before'])) {
                    $tag['before'] = strtr($tag['before'], $params);

function sort_array(&$array1, &$array2)
{
    for ($i = 0; $i < sizeof($array1); $i++) {
        for ($j = 0; $j < sizeof($array1); $j++) {
            if ($array1[$i] > $array1[$j]) {
                permute($array1[$i], $array1[$j]);
                permute($array2[$i], $array2[$j]);
            }
        }
    }
}