Problem with arrays :(

[50GPHP]

k so i have 2 arrays in a dice game and basically the idea is if the dg_array is empty the have won 😛!
dg stands for dice guessed and do starts for dice outcome, i want is to checkeach dg with each do then if they are equal take them both out of their array.
below is my attempt lol!

foreach($dg_array as $dg){
  foreach($do_array as $do){
   if($do=$dg){
     unset($do);
     unset($dg);
   }
  }
}

thanx,
50G

[50GPHP]

i guess i cud do (considering i counted the dice before in the code):

if($do_array[0]==$dg_array[0]){
$currentcorrect++;
$dg_array[0]=0;
}

and do it for each combination but wud be better if there was a shorter way 🙁

[laserlight]

Sort the arrays and compare (with a single simultaneous pass through both arrays). If dg_array is a subset of do_array, then the user has won.

This is a possible implementation:

function checkWin($guesses, $outcomes) {
    $guess_count = count($guesses);
    $outcome_count = count($outcomes);

if ($guess_count <= $outcome_count) {
    sort($guesses);
    sort($outcomes);

    $i = 0;
    for ($j = 0; $i < $guess_count && $j < $outcome_count; ++$j) {
        if ($guesses[$i] == $outcomes[$j]) {
            ++$i;
        }
    }
    return $i == $guess_count;
} else {
    return false;
}
}

[50GPHP]

heh beleive it or not i found a way around it quite similair 😛

for($i=0; $i<3; $i++)
{
    for($j=0; $j<3; $j++)
    {
        if ($do_array[$i] == $dg_array[$j])
        {
            $currentcorrect++;
            $dg_array[$j]=0;    // clear it so it wont be used again
            break;                    // break out of the J loop as we found a match
        }
    }
}

really grateful for your time/effort tho thanx alot 😛

[Weedpacket]

Remove all the elements in $dg_array that appear in $do_array:

$dg_array = array_diff($dg_array, $do_array);

Remove elements in $dg_array and $do_array that are common to both:

$in_both_arrays = array_intersect($dg_array, $do_array);
$dg_array = array_diff($dg_array, $in_both_arrays);
$do_array = array_diff($do_array, $in_both_arrays);

[laserlight]

heh beleive it or not i found a way around it quite similair 😛

The complexity is very different though. The sorts should run in "linear-logarithmic" time, while checking if the dg_array is a subset of the do_array (with distinct though repeated elements) takes linear time. But your algorithm runs in quadratic time, which means that it is likely to be slower than my algorithm when the guess and outcome arrays are large.

Remove all the elements in $dg_array that appear in $do_array:

The way I see it, Weedpacket, is that array_diff() will not work here, since it may be possible to have repeated guesses and outcomes.

[Weedpacket]

laserlight wrote:

The complexity is very different though.

In other words, not that similar after all 🙂

The way I see it, Weedpacket, is that array_diff() will not work here, since it may be possible to have repeated guesses and outcomes.

Oh, yes. For some reason I thought of the array of outcomes as a set - that the values would all be distinct. In fact they're actual outcomes, not possible outcomes. I think it was those nested loops that go up to 3 that threw me. If the arrays really are that small I'd seriously consider listing cases explicitly.

If the arrays are going to be large, though, with a limited number of possible outcomes and the order is irrelevant (if the order matters then array_diff_assoc() could be used instead to find matching pairs), then keeping a count of each outcome as it happens might be more efficient. Instead of array(4,3,6,5,2,2,1,5,3,3,6,2,4,3,3,1) there's array(1=>2, 2=>3, 3=>5, 4=>2, 5=>2, 6=>2).

$possible_outcomes = array(1,2,3,4,5,6, 'yahtzee');
foreach($possible_outcomes as $outcome)
{
    $matches = min($do_array[$outcome], $dg_array[$outcome]);
    $do_array[$outcome]-=$matches;
    $dg_array[$outcome]-=$matches;
}

Constant in time, constant in space, the $possible_outcomes array would be useful elsewhere, and the win comes when array_sum($dg_array)==0.