[php] 24 game

[Verwijderd]

Hoi,

Een tijd geleden had je flippo's waar 4 cijfers op stonden. Door middel van plus, min, keer en gedeeld door moest je 24 maken.

Bijv:

5,4,6,2

6*5 = 30
30 - 4 = 26
26 - 2 = 24

Is er een manier om (door middel van het invoeren van 4 getallen) uit te rekenen op welke manier dit kan?

Je moet er rekening mee houden dat het niet op de volgorde cijfer 1, dan cijfer 2, dan cijfer 3, dan cijfer 4 kan.

Er zijn 4*3*2*1 mogelijkheden voor het plaatsen van de cijfers. Er zijn 4 operatoren (+, -, /, *), dus er zijn 4*3*2*1*4*4*4 mogelijkheden (1536).

Natuurlijk is het mogelijk ze allemaal langs te gaan. Is er misschien een andere, makkelijkere manier die ik over het hoofd zie?

Ik wil dit namelijk gaan verwerken in een phpscriptje.

Bedankt

Dirkjan

[ Voor 10% gewijzigd door Verwijderd op 03-11-2003 16:21 ]

[.oisyn]

Ik had toen die flippo's er waren gewoon een brute force algo gemaakt. Best te doen, want erg veel mogelijkheden zijn er niet. Overigens klopt je aantal-mogelijkheden-berekening niet, want je houdt geen rekening met haakjes (iets als (3+4)*(5+6) komt niet voor in jouw berekening)

[Verwijderd]

zijn haakjes toegestaan dan bij dat spel? ik begin dan in ieder geval met mijn script ZONDER haakjes.. dat kan ik altijd nog toevoegen ;-)

[Winnetou]

Volgens mij was het wel "met haakjes".
Bijvoorbeeld: [6,6,6,2] (of natuurlijk ook [6,2,6,6])
Je mocht toch doen van
6*6=36
6*2=12
36-12=24

[ Voor 17% gewijzigd door Winnetou op 03-11-2003 18:37 ]

[Hu9o]

Nee er mochten geen haakjes gebruikt worden. Want dat is voor de meeste Breazehaz te moeilijk namelijk.

[.oisyn]

alwinh: Idd, en voor iemand zegt "ja maar dat is de logische volgorde van 6*6 - 6*2": er was er ook een met 3, 3, 7, 7

met als oplossing: (3/7 + 3) * 7 (was wel een moeilijke overigens, daar kom je niet zo op )

Hu9o: oh please, de 24 game flippo's waren er lang voor de breezers

[ Voor 19% gewijzigd door .oisyn op 03-11-2003 16:40 ]

[drm]

Hu9o:
Nee er mochten geen haakjes gebruikt worden. Want dat is voor de meeste Breazehaz te moeilijk namelijk.

Jij wou zeggen dat al die puzzeltjes makkelijk waren, dan?

[Verwijderd]

Hu9o schreef op 03 november 2003 @ 16:37:
Nee er mochten geen haakjes gebruikt worden. Want dat is voor de meeste Breazehaz te moeilijk namelijk.

er mochten wel haakjes gebruikt worden.. je moest gewoon de snelste zijn.. maakte niet uit hoe..ze gingen evengoed wel je berekening na

[Verwijderd]

Leuk project, ik veronderstel dat je er dan ook het resultaat van laat zien?

Je kan er namelijk wel een leuke functie van maken hé

Alvast veel succes..

[jvo]

Hmm, doet me erg denken aan opgave 3 van het afgelopen nk programmeren. Maar dan was het met romeinse cijfers, in postfix notatie en met als antwoord 42 i.p.v. 24. De hele beschijving staat op de site van nkp 2003. Je mag m'n source wel hebben, maar het is wel wat uitgebreider (vanwege de romeinse cijfers) en in java.

Trouwens, die uitwerking werkt heel simpel recursief.

[ Voor 16% gewijzigd door jvo op 03-11-2003 17:01 . Reden: Uitbreiding ]

[SPee]

Probeer je een cheat programma te maken of een info website?

Je kan als spel ook 4 nummers geven, dat de bezoekers de formule invullen en jij die dan uitrekend. Is misschien wat makkelijker/leuker.

Anders moet je waarschijnlijk per mogelijkheid een functie ervoor maken die het antwoord teruggeeft.

dus bv.

code:

boolean function AlleenOptellen(int a, int b, int c, int d){
   if(24==(a+b+c+d)){ return true; } else { return false; };
}

En dan per combinatie. En kun je daar elke keer andere waardes voor die a, b, c en d doorgeven.

Zal wel groot worden, maar lijkt mij het makkelijkst. Of weet iemand nog een makkelijkere manier.

[.oisyn]

Spee lekker omslachtig, dan kun je beter het geheel verpakken in een loopje

[Verwijderd]

Alle functies maken lijkt me een beetje veel werk.

Als je gewoon alle mogelijkheden maakt als string,
en die vervolgens eval'ed en checkt of het goede
getal eruit komt ben je denk ik sneller klaar.

[Woy]

offtopic:
Mischien leuk om een computer variant van dit puzzeltje te maken die ook gebruik mag maken van andere rekenkundige functies zoals mod en machten

[Verwijderd]

hmm ik ben aardig op weg, ookal is het misschien een omslachtige manier ik post hem binnen een half uurtje denk ik :-)

[jvo]

Verwijderd schreef op 03 november 2003 @ 21:23:
hmm ik ben aardig op weg, ookal is het misschien een omslachtige manier ik post hem binnen een half uurtje denk ik :-)

offtopic:
Ik hoor tromgeroffel

[Verwijderd]

hij werkt, opslaan als test.php:

ik ga nu alleen nog ff een functie maken dat hij weergeeft dat er geen combinaties bestaan als er niks gevonden wordt.

Let op bruut force, maar als ie niks vindt is de kans héél groot dat het niet mogelijk is

PHP:

<?
function vierentwintig($een, $twee, $drie, $vier)
 {
 for($i = 0; $i < 1000; $i++)
  {
  $random_een = rand(1,4);
  $random_twee = rand(1,4);
  $random_drie = rand(1,4);
  if($random_een == 1)
   {
   $uitkomst = $een + $twee;
   }
  elseif($random_een == 2)
   {
   $uitkomst = $een - $twee;
   }
  elseif($random_een == 3)
   {
   $uitkomst = $een * $twee;
   }
  elseif($random_een == 4)
   {
   $uitkomst = $een / $twee;
   }
  if($random_twee == 1)
   {
   $uitkomst = $uitkomst + $drie;
   }
  elseif($random_twee == 2)
   {
   $uitkomst = $uitkomst - $drie;
   }
  elseif($random_twee == 3)
   {
   $uitkomst = $uitkomst * $drie;
   }
  elseif($random_twee == 4)
   {
   $uitkomst = $uitkomst / $drie;
   }
  if($random_drie == 1)
   {
   $uitkomst = $uitkomst + $vier;
   }
  elseif($random_drie == 2)
   {
   $uitkomst = $uitkomst - $vier;
   }
  elseif($random_drie == 3)
   {
   $uitkomst = $uitkomst * $vier;
   }
  elseif($random_drie == 4)
   {
   $uitkomst = $uitkomst / $vier;
   }
  if($uitkomst == 24)
   {
   $random_een = str_replace("1","+", $random_een);
   $random_een = str_replace("2","-", $random_een);
   $random_een = str_replace("3","*", $random_een);
   $random_een = str_replace("4","/", $random_een);

   $random_twee = str_replace("1","+", $random_twee);
   $random_twee = str_replace("2","-", $random_twee);
   $random_twee = str_replace("3","*", $random_twee);
   $random_twee = str_replace("4","/", $random_twee);

   $random_drie = str_replace("1","+", $random_drie);
   $random_drie = str_replace("2","-", $random_drie);
   $random_drie = str_replace("3","*", $random_drie);
   $random_drie = str_replace("4","/", $random_drie);
   die("$een $random_een $twee $random_twee $drie $random_drie $vier");
   }
  }
 }

 if($_GET['verstuur'] == "ja")
  {
  $een = $_POST['een'];
  $twee = $_POST['twee'];
  $drie = $_POST['drie'];
  $vier = $_POST['vier'];
  vierentwintig("$een","$twee","$drie","$vier");
  vierentwintig("$een","$twee","$vier","$drie");
  vierentwintig("$een","$drie","$twee","$vier");
  vierentwintig("$een","$drie","$vier","$twee");
  vierentwintig("$een","$vier","$twee","$drie");
  vierentwintig("$een","$vier","$drie","$twee");

  vierentwintig("$twee","$een","$drie","$vier");
  vierentwintig("$twee","$een","$vier","$drie");
  vierentwintig("$twee","$drie","$een","$vier");
  vierentwintig("$twee","$drie","$vier","$een");
  vierentwintig("$twee","$vier","$een","$drie");
  vierentwintig("$twee","$vier","$drie","$een");

  vierentwintig("$drie","$een","$twee","$vier");
  vierentwintig("$drie","$een","$vier","$twee");
  vierentwintig("$drie","$twee","$een","$vier");
  vierentwintig("$drie","$twee","$vier","$een");
  vierentwintig("$drie","$vier","$een","$twee");
  vierentwintig("$drie","$vier","$twee","$een");

  vierentwintig("$vier","$een","$twee","$drie");
  vierentwintig("$vier","$een","$drie","$twee");
  vierentwintig("$vier","$twee","$een","$drie");
  vierentwintig("$vier","$twee","$drie","$een");
  vierentwintig("$vier","$drie","$een","$twee");
  vierentwintig("$vier","$drie","$twee","$een");
  }
 else
  {
?>
<form method="post" action="test.php?verstuur=ja">
 getal 1: <input type="text" name="een"><br>
 getal 2: <input type="text" name="twee"><br>
 getal 3: <input type="text" name="drie"><br>
 getal 4: <input type="text" name="vier"><br>
 <input type="submit" value="verstuur">
</form>
<?
 }
?>

[ Voor 76% gewijzigd door Verwijderd op 03-11-2003 21:48 ]

[.oisyn]

waarom random
en waarom "$variabele" tussen quotes?

[windancer]

Volgens mij is het het gemakkelijkst te doen door gebruik te maken van zogenaamde Reverse Polish Notation (RPN), zoals iemand eerder in deze thread al opmerkte. Je hebt dan geen haakjes nodig en dat scheelt een hoop.

[Verwijderd]

.oisyn schreef op 03 november 2003 @ 21:48:
waarom random
en waarom "$variabele" tussen quotes?

ik bengeen superprof in dit soort programmaatjes dit vindt ik al heel wat... ;-)

maar die quotes, bedoel je bij de functie?

en ik ga er nog wat verbeteringen in brengen

oja: getest op 22 flippos die ik kon vinden, hij vondt de oplossing elke keer

[ Voor 22% gewijzigd door Verwijderd op 03-11-2003 21:53 ]

[jj85]

De notatie klopt niet altijd even goed, de ene keer moet je er wel haakjes bij denken en de andere keer weer niet.

[mjax]

Verwijderd schreef op 03 november 2003 @ 21:46:
Let op bruut force, maar als ie niks vindt is de kans héél groot dat het niet mogelijk is

Volgens mij heeft deze oplossing weinig met bruteforce te maken, maar meer met geluk. Je probeert nl. gewoon 1000 willekeurige combinaties uit en stopt dan! Brute force zou betekenen dat je ALLE mogelijkheden afgaat, in dit geval alle combinaties van de 4 getallen met daar doorheen een mix van operatoren.

Dat je dit het beste in RPN kunt doen mag inmiddels duidelijk zijn.

De charme van dit soort opdrachten lijkt mij een zo doordacht en mooi mogelijk algoritme te verzinnen dat de oplossingen genereert.

Ik heb in de flippo tijd ook eens zo'n tool geschreven die botweg alle mogelijkheden afging. Weliswaar in Delphi 1.0, maar toch! Als ik de source nog ergens kan opduiken, zal ik 'm hier neerzetten.

Overigens, offtopic, over RPN gesproken: kent iemand nog die rekenmachines waarbij je op basis van RPN rekenopdrachten moest invoeren? Ik heb tijdens mijn HIO opleiding zo'n ding 4 jaar lang gebruikt en ik was er helemaal weg van. Veel sneller dan dat gedoe met haakjes, als je eenmaal door hebt hoe het werkt. Ik geloof dat ik 'm op zolder nog ergens heb liggen. Misschien toch eens uit de kast halen, want hij was ook programmeerbaar en ik heb er ooit (in die paar kbytes die beschikbaar waren) een heus pokerspel in geschreven, inclusief grafische kaarten!

[ Voor 32% gewijzigd door mjax op 03-11-2003 22:03 ]

[Verwijderd]

vogelspin schreef op 03 november 2003 @ 21:54:
De notatie klopt niet altijd even goed, de ene keer moet je er wel haakjes bij denken en de andere keer weer niet.

Het werkt niet op meneer van dale wacht op antwoord..

Het is gewoon stap voor stap op volgorde, net zoals het bij de flippo's was.

[jj85]

Verwijderd schreef op 03 november 2003 @ 21:59:
[...]


Het werkt niet op meneer van dale wacht op antwoord..

Het is gewoon stap voor stap op volgorde, net zoals het bij de flippo's was.

Dan doet ie dat wel raar, bijvoorbeeld
25*24-24*24

[Verwijderd]

Bewerkt (update):

Nu zonder 'gokken', met melding wanneer er geen combinaties zijn en je kunt het standaardgetal (24) wijzigen:

PHP:

<?
function vierentwintig($een, $twee, $drie, $vier, $input=24)
 {
$uitkomst = $een+$twee+$drie+$vier; if($uitkomst == $input) { die("$een + $twee + $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee+$drie-$vier; if($uitkomst == $input) { die("$een + $twee + $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee+$drie*$vier; if($uitkomst == $input) { die("$een + $twee + $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee+$drie/$vier; if($uitkomst == $input) { die("$een + $twee + $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee-$drie+$vier; if($uitkomst == $input) { die("$een + $twee - $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee-$drie-$vier; if($uitkomst == $input) { die("$een + $twee - $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee-$drie*$vier; if($uitkomst == $input) { die("$een + $twee - $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee-$drie/$vier; if($uitkomst == $input) { die("$een + $twee - $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee*$drie+$vier; if($uitkomst == $input) { die("$een + $twee * $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee*$drie-$vier; if($uitkomst == $input) { die("$een + $twee * $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee*$drie*$vier; if($uitkomst == $input) { die("$een + $twee * $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee*$drie/$vier; if($uitkomst == $input) { die("$een + $twee * $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee/$drie+$vier; if($uitkomst == $input) { die("$een + $twee / $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee/$drie-$vier; if($uitkomst == $input) { die("$een + $twee / $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee/$drie*$vier; if($uitkomst == $input) { die("$een + $twee / $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een+$twee/$drie/$vier; if($uitkomst == $input) { die("$een + $twee / $drie / $vier <br>"); $oke = 1; }

$uitkomst = $een-$twee+$drie+$vier; if($uitkomst == $input) { die("$een - $twee + $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee+$drie-$vier; if($uitkomst == $input) { die("$een - $twee + $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee+$drie*$vier; if($uitkomst == $input) { die("$een - $twee + $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee+$drie/$vier; if($uitkomst == $input) { die("$een - $twee + $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee-$drie+$vier; if($uitkomst == $input) { die("$een - $twee - $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee-$drie-$vier; if($uitkomst == $input) { die("$een - $twee - $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee-$drie*$vier; if($uitkomst == $input) { die("$een - $twee - $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee-$drie/$vier; if($uitkomst == $input) { die("$een - $twee - $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee*$drie+$vier; if($uitkomst == $input) { die("$een - $twee * $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee*$drie-$vier; if($uitkomst == $input) { die("$een - $twee * $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee*$drie*$vier; if($uitkomst == $input) { die("$een - $twee * $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee*$drie/$vier; if($uitkomst == $input) { die("$een - $twee * $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee/$drie+$vier; if($uitkomst == $input) { die("$een - $twee / $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee/$drie-$vier; if($uitkomst == $input) { die("$een - $twee / $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee/$drie*$vier; if($uitkomst == $input) { die("$een - $twee / $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een-$twee/$drie/$vier; if($uitkomst == $input) { die("$een - $twee / $drie / $vier <br>"); $oke = 1; }

$uitkomst = $een*$twee+$drie+$vier; if($uitkomst == $input) { die("$een * $twee + $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee+$drie-$vier; if($uitkomst == $input) { die("$een * $twee + $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee+$drie*$vier; if($uitkomst == $input) { die("$een * $twee + $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee+$drie/$vier; if($uitkomst == $input) { die("$een * $twee + $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee-$drie+$vier; if($uitkomst == $input) { die("$een * $twee - $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee-$drie-$vier; if($uitkomst == $input) { die("$een * $twee - $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee-$drie*$vier; if($uitkomst == $input) { die("$een * $twee - $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee-$drie/$vier; if($uitkomst == $input) { die("$een * $twee - $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee*$drie+$vier; if($uitkomst == $input) { die("$een * $twee * $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee*$drie-$vier; if($uitkomst == $input) { die("$een * $twee * $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee*$drie*$vier; if($uitkomst == $input) { die("$een * $twee * $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee*$drie/$vier; if($uitkomst == $input) { die("$een * $twee * $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee/$drie+$vier; if($uitkomst == $input) { die("$een * $twee / $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee/$drie-$vier; if($uitkomst == $input) { die("$een * $twee / $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee/$drie*$vier; if($uitkomst == $input) { die("$een * $twee / $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een*$twee/$drie/$vier; if($uitkomst == $input) { die("$een * $twee / $drie / $vier <br>"); $oke = 1; }

$uitkomst = $een/$twee+$drie+$vier; if($uitkomst == $input) { die("$een / $twee + $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee+$drie-$vier; if($uitkomst == $input) { die("$een / $twee + $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee+$drie*$vier; if($uitkomst == $input) { die("$een / $twee + $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee+$drie/$vier; if($uitkomst == $input) { die("$een / $twee + $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee-$drie+$vier; if($uitkomst == $input) { die("$een / $twee - $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee-$drie-$vier; if($uitkomst == $input) { die("$een / $twee - $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee-$drie*$vier; if($uitkomst == $input) { die("$een / $twee - $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee-$drie/$vier; if($uitkomst == $input) { die("$een / $twee - $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee*$drie+$vier; if($uitkomst == $input) { die("$een / $twee * $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee*$drie-$vier; if($uitkomst == $input) { die("$een / $twee * $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee*$drie*$vier; if($uitkomst == $input) { die("$een / $twee * $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee*$drie/$vier; if($uitkomst == $input) { die("$een / $twee * $drie / $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee/$drie+$vier; if($uitkomst == $input) { die("$een / $twee / $drie + $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee/$drie-$vier; if($uitkomst == $input) { die("$een / $twee / $drie - $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee/$drie*$vier; if($uitkomst == $input) { die("$een / $twee / $drie * $vier <br>"); $oke = 1; }
$uitkomst = $een/$twee/$drie/$vier; if($uitkomst == $input) { die("$een / $twee / $drie / $vier <br>"); $oke = 1; }
 }

 if($_GET['verstuur'] == "ja")
  {
  $een = $_POST['een'];
  $twee = $_POST['twee'];
  $drie = $_POST['drie'];
  $vier = $_POST['vier'];
  vierentwintig($een,$twee,$drie,$vier);
  vierentwintig($een,$twee,$vier,$drie);
  vierentwintig($een,$drie,$twee,$vier);
  vierentwintig($een,$drie,$vier,$twee);
  vierentwintig($een,$vier,$twee,$drie);
  vierentwintig($een,$vier,$drie,$twee);

  vierentwintig($twee,$een,$drie,$vier);
  vierentwintig($twee,$een,$vier,$drie);
  vierentwintig($twee,$drie,$een,$vier);
  vierentwintig($twee,$drie,$vier,$een);
  vierentwintig($twee,$vier,$een,$drie);
  vierentwintig($twee,$vier,$drie,$een);

  vierentwintig($drie,$een,$twee,$vier);
  vierentwintig($drie,$een,$vier,$twee);
  vierentwintig($drie,$twee,$een,$vier);
  vierentwintig($drie,$twee,$vier,$een);
  vierentwintig($drie,$vier,$een,$twee);
  vierentwintig($drie,$vier,$twee,$een);

  vierentwintig($vier,$een,$twee,$drie);
  vierentwintig($vier,$een,$drie,$twee);
  vierentwintig($vier,$twee,$een,$drie);
  vierentwintig($vier,$twee,$drie,$een);
  vierentwintig($vier,$drie,$een,$twee);
  vierentwintig($vier,$drie,$twee,$een);
  echo "Er zijn geen combinaties gevonden.";
  }
 else
  {
?>
<form method="post" action="test.php?verstuur=ja">
 getal 1: <input type="text" name="een"><br>
 getal 2: <input type="text" name="twee"><br>
 getal 3: <input type="text" name="drie"><br>
 getal 4: <input type="text" name="vier"><br>
 <input type="submit" value="verstuur">
</form>
<?
 }
?>

[ Voor 25% gewijzigd door Verwijderd op 03-11-2003 22:32 ]

[Verwijderd]

weet iemand hoe je een operator in een variabele kan zetten en nog wel gebruiken? want ik ben ook even bezig, maar heb niet zoveel zin om alles uit te typen zoals TS

[Verwijderd]

Verwijderd schreef op 03 november 2003 @ 22:30:
weet iemand hoe je een operator in een variabele kan zetten en nog wel gebruiken? want ik ben ook even bezig, maar heb niet zoveel zin om alles uit te typen zoals TS

Daar kwam ik dus ook niet uit daarom heb ik het zo gedaan

[Verwijderd]

Er zit nog ergens een foutje in, ik ben ermee bezig

als iemand weet hoe je hier 24 van maakt (kan niet volgens mijn script, wel volgens smiths, nu lays:

7, 3, 3, 5

[ Voor 53% gewijzigd door Verwijderd op 03-11-2003 22:36 ]

[Woy]

Verwijderd schreef op 03 november 2003 @ 22:30:
weet iemand hoe je een operator in een variabele kan zetten en nog wel gebruiken? want ik ben ook even bezig, maar heb niet zoveel zin om alles uit te typen zoals TS

Ik weet niet hoe php werkt met functie pointers of met objecten maar je zou bijvoorbeeld 2 functies of objecten kunnen maken als volgt

C#:

interface Operator
{
    double Execute( double lh, double rh );
}
class MultiplyOperator : Operator
{
    public double Execute( double lh, double rh )
    {
        return lh * rh;
    }
}
class AddOperator : Operator
{
    public double Execute( double lh, double rh )
    {
        return lh + rh;
    }
}

En dan gewoon overal gebruik maken van een Operator en Execute aanroepen. Ik denk niet dat je een operator op kunt slaan in een variabele.

[Nvidiot]

mjax schreef op 03 november 2003 @ 21:58:
[...]


Overigens, offtopic, over RPN gesproken: kent iemand nog die rekenmachines waarbij je op basis van RPN rekenopdrachten moest invoeren? Ik heb tijdens mijn HIO opleiding zo'n ding 4 jaar lang gebruikt en ik was er helemaal weg van. Veel sneller dan dat gedoe met haakjes, als je eenmaal door hebt hoe het werkt. Ik geloof dat ik 'm op zolder nog ergens heb liggen. Misschien toch eens uit de kast halen, want hij was ook programmeerbaar en ik heb er ooit (in die paar kbytes die beschikbaar waren) een heus pokerspel in geschreven, inclusief grafische kaarten!

De grafische rekenmachines van HP (als je die nog kunt vinden) kunnen dit, evenals de Ti-89 / 92 / 92+ (met behulp van een programma )
Misschien dat de Ti-82 en co. het ook kunnen met behulp van een basic programma, dat weet ik niet zeker

[jvo]

Verwijderd schreef op 03 november 2003 @ 22:26:
Bewerkt (update):

Nu zonder 'gokken', met melding wanneer er geen combinaties zijn en je kunt het standaardgetal (24) wijzigen:

De knetter, dat moet korter kunnen. Ik zou ze gewoon in postfix genereren en dan omzetten naar infix met haakjes als het antwoord 24 is. Als ik de tijd en zin vind post ik wel wat.

Maar, even met alle respect, een oplossing is een oplossing en goed is goed

Trouwens is het de bedoeling dat er dubbelen in voorkomen? Ik neem aan van niet.
En (2+4)*(2+2) en (4+2)*(2+2), wil je die allebei zien? Ik neem ook aan van niet.

[Verwijderd]

jvo schreef op 03 november 2003 @ 22:41:
[...]

De knetter, dat moet korter kunnen. Ik zou ze gewoon in postfix genereren en dan omzetten naar infix met haakjes als het antwoord 24 is. Als ik de tijd en zin vind post ik wel wat.

Maar, even met alle respect, een oplossing is een oplossing en goed is goed

Trouwens is het de bedoeling dat er dubbelen in voorkomen? Ik neem aan van niet.
En (2+4)*(2+2) en (4+2)*(2+2), wil je die allebei zien? Ik neem ook aan van niet.

er wordt er nu maar een weergegeven

maar check mijn vraag (drie reacties hierboven ofzow)

[sirdupre]

Verwijderd schreef op 03 november 2003 @ 22:30:
weet iemand hoe je een operator in een variabele kan zetten en nog wel gebruiken? want ik ben ook even bezig, maar heb niet zoveel zin om alles uit te typen zoals TS

Iets als dit misschien (ik test dit niet uit)

code:

function calc ($a, $operator, $b)
{
if ($operator==1) return $a+$b;
if ($operator==2) return $a-$b;
if ($operator==3) return $a*$b;
if ($operator==4) return $a/$b;
return 0;
}

Je zou in plaats van integers voor de operators ook strings of chars kunnen gebruiken, maar in dit geval leek het mij makkelijk om integers te gebruiken zodat je deze functie in een for loopje kan gebruiken.

[ Voor 72% gewijzigd door sirdupre op 03-11-2003 23:03 . Reden: nieuw idee ]

[.oisyn]

kijk nog eens naar de code van rwb, en combineer dat met arrays

PHP:

function add ($a, $b) { return $a + $b; }
function sub ($a, $b) { return $a - $b; }
function mul ($a, $b) { return $a * $b; }
function div ($a, $b) { return $a / $b; }

$operators = array ("add", "sub", "mul", "div");

en dan is het simpelweg alle elementen in de array aflopen

PHP:

$a = 10;
$b = 20;

foreach ($operators as $op)
{
    echo $op ($a, $b);
}

[RobIII]

In Javascript, brute kracht :

HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
<head>
    <title>Flippo</title>
    <script>
        var arrValues = new Array(3);
        var arrOps = new Array('+','-','*','/');
        var strResult;
        
        function calc() {
            var valUnused = new Array(), p = new Array(), i;
            var n=4;
            
            strResult='';
            
            initArr();

            for(i=1; i <= n; i++) valUnused[i] = new Number(1);
            permute(valUnused, p, 1, n,arrValues);
    
            document.getElementById('dvResults').innerText = ((strResult.length == 0) ? 'Er zijn geen resultaten voor ' + arrValues : strResult );
        }
        
        function initArr() {
            for (x=0;x<4;x++) arrValues[x]=document.getElementById('inp' + x).value;
        }
        
        function check(arrCheck) {
            var x,y,z,q;
            var strFormula;
            
            for (x=0;x<64;x++) {
                strFormula = arrCheck[1] + arrOps[x & 3] + arrCheck[2] + arrOps[(x >> 2) & 3] + arrCheck[3] + arrOps[(x >> 4) & 3] + arrCheck[4];
                if ((eval(strFormula)==24) && (strResult.indexOf(strFormula)<0)) strResult += strFormula + ' = 24\n';
            }
        }

        function permute(unused, p, L, N, arrSource) {
            var i;
            if(L > N) { // process the permutation p
                check(p);
            } else {
                for(i = 1; i <=N; i++) // i.e. for each i in unused
                if(unused[i] == 1) {
                    unused[i]=0; // i is now used
                    p[L]=arrSource[i-1];
                    permute(unused, p, L+1, N,arrSource); // recursive call
                    unused[i]=1; // free i
                }
            }
        }

    </script>
</head>

<body>
    <form name="frmWaarde">
        Waarde 1: <input id="inp0" type="text" maxlength="2" value=""><br>
        Waarde 2: <input id="inp1" type="text" maxlength="2" value=""><br>
        Waarde 3: <input id="inp2" type="text" maxlength="2" value=""><br>
        Waarde 4: <input id="inp3" type="text" maxlength="2" value=""><br>
        <input type="button" value="Bereken!" onclick="calc();">
    </form>
    <div id="dvResults" style="overflow:auto;height:50%;border:1 solid #000000;font-family:courier,courier new;"></div>
</body>
</html>

Lang leve eval
Overigens worden cijfers hier niet van plek gewisseld en klooi ik nog niet met haakjes. Dat zou eventueel ook nog kunnen met een extra loopje eromheen...

/Dirty mode

[ Voor 102% gewijzigd door RobIII op 06-11-2003 17:37 ]

[jvo]

Verwijderd schreef op 03 november 2003 @ 22:43:
[...]


er wordt er nu maar een weergegeven

maar check mijn vraag (drie reacties hierboven ofzow)

3, 3, 5, 7 --> (3*5-7)*3
Met m'n source van het nkp

[ Voor 8% gewijzigd door jvo op 03-11-2003 22:59 ]

[JeRa]

Sorry, maar ik moet jullie leuke hersenspinsels toch even bruut onderbreken met misschien een grote tip (als je het in PHP doet, tenminste): eval()

[RobIII]

JeRa schreef op 03 november 2003 @ 22:59:
Sorry, maar ik moet jullie leuke hersenspinsels toch even bruut onderbreken met misschien een grote tip (als je het in PHP doet, tenminste): eval()

* RobIII was je voor

[JeRa]

RobIII schreef op 03 november 2003 @ 23:01:
[...]

* RobIII was je voor

In Javascript, ja

Check de topictitel

[ Voor 12% gewijzigd door JeRa op 03-11-2003 23:02 ]

[SchizoDuckie]

.oisyn schreef op 03 november 2003 @ 22:53:
kijk nog eens naar de code van rwb, en combineer dat met arrays

PHP:

function add ($a, $b) { return $a + $b; }
function sub ($a, $b) { return $a - $b; }
function mul ($a, $b) { return $a * $b; }
function div ($a, $b) { return $a / $b; }

$operators = array ("add", "sub", "mul", "div");

en dan is het simpelweg alle elementen in de array aflopen

PHP:

$a = 10;
$b = 20;

foreach ($operators as $op)
{
    echo $op ($a, $b);
}

WTF werkt dat
Zomaar een functie in een variabele pleuren en die daarna executen met een echo

[.oisyn]

RobIII schreef op 03 november 2003 @ 23:01:
[...]

* RobIII was je voor

jij pakt de getallen in de volgorde hoe je ze opgeeft. De getallen zelf kun je natuurlijk ook nog omhusselen

[Cavorka]

@Door webfreaky - Monday 03 November 2003 22:26:
Lol, sorry hoor, maar persoonlijk vind ik dit een beetje vreemd... en ook totaal niet op een algoritme lijken. Je hebt alle oplossingen handmatig ingevoerd.

Er zit totaal geen onafhankelijkheid in. Als je het nu bijvoorbeeld met 5 cijfers wilt doen, en dan een andere uitkomst werkt het helemaal niet meer.

Ik zou dit proberen:
probeer je operatoren als functie te schrijven en dan je script alle mogelijke combinaties van de n-cijfers en de m-operatoren te laten uitrekenen, allemaal uitrekenen > goede uitkomst. Driewerf hoera voor brute force, waar de hell hebben we anders al die P4's en AMD XP's voor?

*Edit: WTF? Waar komen al die replies vandaan? Moet echt ff sneller typen. Lijkt wel spuit 11 mode van me.

offtopic:
PS: Ikzelf ben bezig met een script dat de som van alle diagonalen/horizontalen/verticalen uitrekent van een n*n vlak, met cijfers 0 tot n² -1. Dan moet uit elke som (dus alle dia/hori/verti) hetzelfde komen. Dit werkt ook, gewoon pseudo brute forcen. Hierbij heb ik bijvoorbeeld een volledige n-onafhankelijkheid. Komt binnenkort wel een topic over.

[ Voor 22% gewijzigd door Cavorka op 03-11-2003 23:12 ]

[.oisyn]

Papa Eend schreef op 03 november 2003 @ 23:03:
[...]


WTF werkt dat
Zomaar een functie in een variabele pleuren en die daarna executen met een echo

volgens begrijp je niet helemaal wat er gebeurt. Echo echo'd alleen de argumenten die je meegeeft

$op ($a, $b) is dus het argument. $op wijst naar bijvoorbeeld "add". $op ($a, $b) is dan hetzelfde als add ($a, $b)

[SchizoDuckie]

.oisyn schreef op 03 november 2003 @ 23:07:
[...]


volgens begrijp je niet helemaal wat er gebeurt. Echo echo'd alleen de argumenten die je meegeeft

$op ($a, $b) is dus het argument. $op wijst naar bijvoorbeeld "add". $op ($a, $b) is dan hetzelfde als add ($a, $b)

Ja, dat snap ik wel, ik wist alleen niet dat het kon
Daar kan je best sicke dingen mee doen volgens mij

[Verwijderd]

mm, kheb nu, alleen ik weet niet hoe ik de volgordes makkelijk bij langs kan laten gaan en de vorm is altijd
(A -operator- -operator- (C -operator- D)

tot nu mn code:

PHP:

    $a = 6;
    $b = 6;
    $c = 2;
    $d = 6;

    
    function calculate($operator,$een,$twee) {
        if($operator == 0) return $een * $twee;
        elseif($operator == 1) return $een / $twee;
        elseif($operator == 2) return $een + $twee;
        elseif($operator == 3) return $een - $twee;
    }
    
    function operator($operator) {
        if($operator == 0) return "*";
        elseif($operator == 1) return "/";
        elseif($operator == 2) return "+";
        elseif($operator == 3) return "-";
    }

    for($operator1 = 0; $operator1 < 4; $operator1++) {
        for($operator2 = 0; $operator2 < 4; $operator2++) {
            for($operator3 = 0; $operator3 < 4; $operator3++) {
                $uitkomst = calculate($operator1,calculate($operator2,$a,$b),calculate($operator3,$c,$d));
                $berekening = $a.operator($operator1).$b.operator($operator2).$c.operator($operator3).$d."=".$uitkomst;
                if($uitkomst != 24) {
                    echo $berekening."<br>\n";
                } else {
                    echo "<b>".$berekening."</b>";
                    exit;
                }
            }
        }
    }

[SchizoDuckie]

Papa Eend schreef op 03 november 2003 @ 23:11:
[...]


Ja, dat snap ik wel, ik wist alleen niet dat het kon
Daar kan je best sicke dingen mee doen volgens mij

edit:
volgens mij zou je zo zelfs door met array_push en array_pop (om de volgorde van de array met cijfers te veranderen) binnen een regel of 10 alle combinaties af kunnen lopen

[.oisyn]

Zo, heb maar even een scriptje geschreven dat alles vind
http://www.oisyn.nl/tests/24game.php

Je kan 'm ook alle mogelijke combinaties laten vinden, maar dat duurt nogal lang, en het script wordt na 30 seconden afgebroken

De source

.edit: zo, even toegevoegd dat je nu het zoeken naar alle mogelijkheden ergens anders kunt beginnen, zodat je nog verder kan als de 30 seconden voorbij zijn

.edit2: zo, wat geoptimized. Nu checkt ie geen dubbele combinaties meer (beetje loos om van bijvoorbeeld 2,2,2,2 24 verschillende combinaties te proberen )
Nu kan ie ze wel allemaal vinden binnen 30 seconde

[ Voor 54% gewijzigd door .oisyn op 04-11-2003 02:03 ]

[mjax]

.oisyn schreef op 04 november 2003 @ 01:32:
Zo, heb maar even een scriptje geschreven dat alles vind
http://www.oisyn.nl/tests/24game.php

Je kan 'm ook alle mogelijke combinaties laten vinden, maar dat duurt nogal lang, en het script wordt na 30 seconden afgebroken

De source

.edit: zo, even toegevoegd dat je nu het zoeken naar alle mogelijkheden ergens anders kunt beginnen, zodat je nog verder kan als de 30 seconden voorbij zijn

.edit2: zo, wat geoptimized. Nu checkt ie geen dubbele combinaties meer (beetje loos om van bijvoorbeeld 2,2,2,2 24 verschillende combinaties te proberen )
Nu kan ie ze wel allemaal vinden binnen 30 seconde

Jij bent de eerste wie een permutatie-generatie-algoritme gebruikt en dat is zeker de netste en meest flexibele oplossing! Zo op het eerste oog lijkt het trouwens wel wat op Dijkstra's algoritme dat volgens mij ook voor het travelling-salesmen probleem gebruikt wordt. Toeval?

[ Voor 5% gewijzigd door mjax op 04-11-2003 08:22 ]

[Verwijderd]

code:

vierentwintig("$een","$twee","$drie","$vier");

Bah ->

code:

vierentwintig($een,$twee,$drie, $vier);

[Woy]

.oisyn schreef op 04 november 2003 @ 01:32:
Zo, heb maar even een scriptje geschreven dat alles vind
http://www.oisyn.nl/tests/24game.php

Je kan 'm ook alle mogelijke combinaties laten vinden, maar dat duurt nogal lang, en het script wordt na 30 seconden afgebroken

De source

.edit: zo, even toegevoegd dat je nu het zoeken naar alle mogelijkheden ergens anders kunt beginnen, zodat je nog verder kan als de 30 seconden voorbij zijn

.edit2: zo, wat geoptimized. Nu checkt ie geen dubbele combinaties meer (beetje loos om van bijvoorbeeld 2,2,2,2 24 verschillende combinaties te proberen )
Nu kan ie ze wel allemaal vinden binnen 30 seconde

Hij klopt niet helemaal. Als je 6,6,6,6 invult en zegt dat je alle antwoorden wilt hebben dan vindt hij de volgende

Gevonden! : (((6 + 6) + 6) + 6)
Gevonden! : ((6 + 6) + (6 + 6))
Gevonden! : ((6 + (6 + 6)) + 6)
Gevonden! : (6 + ((6 + 6) + 6))
Gevonden! : (6 + (6 + (6 + 6)))
Gevonden! : ((6 * 6) - (6 + 6))
Gevonden! : (((6 * 6) - 6) - 6)

De eerste 5 zijn exact dezelfde want de haakjes hebben immers geen enkel nut. Anders. En bij 1,3,4 en 5 kan je zelfs de haakjes laten staan en ze zo herordenen dat ze exact hetzelfde zijn. Het haalt tenslotte niet uit of je (6 + 6) + 6 of 6 + (6 + 6) schrijft.



edit:

Overigens niet alleen als je allemaal dezelfde getallen invult. Als je bijvoorbeeld 1,2,3,4 doet krijg je onder andere ook

Gevonden! : (4 * ((1 * 2) * 3))
Gevonden! : (((1 * 2) * 3) * 4)

Wat natuurlijk ook precies hetzelfde is.

[ Voor 9% gewijzigd door Woy op 04-11-2003 10:49 ]

[jvo]

rwb schreef op 04 november 2003 @ 10:44:
Overigens niet alleen als je allemaal dezelfde getallen invult. Als je bijvoorbeeld 1,2,3,4 doet krijg je onder andere ook

Gevonden! : (4 * ((1 * 2) * 3))
Gevonden! : (((1 * 2) * 3) * 4)

Wat natuurlijk ook precies hetzelfde is.

Misschien is het idee om elke combinatie van operators maar 1 keer voor te laten komen. Dus maar een keer x + x + x + x. Kan iemand een voorbeeld verzinnen waarbij er meerdere verschillende mogelijkheden zijn met dezelfde operators?

[ Voor 37% gewijzigd door jvo op 04-11-2003 12:06 . Reden: Quote ingekort ]

[Verwijderd]

Dat is zeker een instinker vraag? Of serieus? Als je allemaal dezelfde operators gebruikt dan is er natuurlijk maar 1 oplossing mogelijk.

[jvo]

Verwijderd schreef op 04 november 2003 @ 12:52:
Dat is zeker een instinker vraag? Of serieus? Als je allemaal dezelfde operators gebruikt dan is er natuurlijk maar 1 oplossing mogelijk.

Nee, serieus. Ik bedoel dat je elke combinatie van operators maar een keer gebruikt. Dus bijvoorbeeld de combinatie twee keer vermenigvuldigen en een keer optellen. Ik vraag me af of er voorbeelden te verzinnen zijn, waarbij eenzelfde combinatie van operators (bijv. *, *, +) tot verschillende antwoorden kan leiden.

Dit zou meteen inhouden dat er dus hoogstens 35 antwoorden mogelijk zijn:
4 dezelfde operators: 4
3 + 1 dezelfde operators: 4 * 3 = 12
2 + 2 dezelfde operators: 4 * 3 / 2 = 6
2 + 1 + 1 dezelfde operators: 4 * 3 * 2 / 2 = 12
4 verschillende operators: 1
Totaal: 35

Dit zou dus betekenen dat er altijd hoogstens 35 echt fundementeel verschillende antwoorden mogelijk zijn. Wie weerlegt het?

[Verwijderd]

Je kunt zeker wel bepaalde combinaties bij bepaalde operatoren uitsluiten:

a * b is namelijk hetzelfde als b * a
a + b is namelijk hetzelfde als b + a

deze eigenschap van operatoren heet in de wiskunde "communicativiteit". Dit geldt alleen voor de + en * operator.

Dus:

(a+b) * (c+d) is gelijk aan:
(b+a) * (c+d) en is gelijk aan:
(c+d) * (a+b) en is gelijk aan
(d+c) * (a+b) en is gelijk aan:
(c+d) * (b+a) enz...

als je hiermee rekening houdt kun je je algoritme nog sneller maken...

[Woy]

Verwijderd schreef op 04 november 2003 @ 14:55:
Je kunt zeker wel bepaalde combinaties bij bepaalde operatoren uitsluiten:

a * b is namelijk hetzelfde als b * a
a + b is namelijk hetzelfde als b + a

deze eigenschap van operatoren heet in de wiskunde "communicativiteit". Dit geldt alleen voor de + en * operator.

Dus:

(a+b) * (c+d) is gelijk aan:
(b+a) * (c+d) en is gelijk aan:
(c+d) * (a+b) en is gelijk aan
(d+c) * (a+b) en is gelijk aan:
(c+d) * (b+a) enz...

als je hiermee rekening houdt kun je je algoritme nog sneller maken...

Dat is natuurlijk nog maar de vraag. Het betreft hier redelijk simpele berekeningen waardoor je goed moet bekijken of de code die je nodig hebt om geval te elimineren niet meer resources gebruikt dan het simpelweg uitrekenen van een geval.

[Verwijderd]

rwb schreef op 04 november 2003 @ 15:04:
[...]

Dat is natuurlijk nog maar de vraag. Het betreft hier redelijk simpele berekeningen waardoor je goed moet bekijken of de code die je nodig hebt om geval te elimineren niet meer resources gebruikt dan het simpelweg uitrekenen van een geval.

Acoord... maar als je bereking alleen * en + bevat hoef je het dus maar 1 keer te berekenen... dat is al iets waar je vrij gemakkelijk rekening mee kunt houden...

Volgens mij als je er nog even iets langer over nadenkt, kun je ook nog wel meer van dit soort makkelijk dingen eruit vissen met was if...then... constructies.

[Woy]

Verwijderd schreef op 04 november 2003 @ 15:07:
[...]


Acoord... maar als je bereking alleen * en + bevat hoef je het dus maar 1 keer te berekenen... dat is al iets waar je vrij gemakkelijk rekening mee kunt houden...

Volgens mij als je er nog even iets langer over nadenkt, kun je ook nog wel meer van dit soort makkelijk dingen eruit vissen met was if...then... constructies.

(a+b) * (c+d) is gelijk aan:
(b+a) * (c+d) en is gelijk aan:
(c+d) * (a+b) en is gelijk aan
(d+c) * (a+b) en is gelijk aan:
(c+d) * (b+a) enz...

Dan moet je wel op een makkelijke manier in je algoritme in kunnen bouwen dat deze allemaal hetzelfde zijn Want als je bijvoorbeeld met dezelfde operatoren en getallen hebt is dit wel anders

code:

(a + b * c) + d

Ik ben het er wel mee eens dat je dit waarschijnlijk wel kunt gebruiken om meer te optimaliseren, maar je moet wel goed opletten dat je niet ontzttend veel reken intensieve code gaat gebruiken om b.v. nog 3 extra gevallen te elimineren.

[Verwijderd]

rwb schreef op 04 november 2003 @ 15:34:
[...]


[...]

Dan moet je wel op een makkelijke manier in je algoritme in kunnen bouwen dat deze allemaal hetzelfde zijn Want als je bijvoorbeeld met dezelfde operatoren en getallen hebt is dit wel anders

code:

(a + b * c) + d

Ik ben het er wel mee eens dat je dit waarschijnlijk wel kunt gebruiken om meer te optimaliseren, maar je moet wel goed opletten dat je niet ontzttend veel reken intensieve code gaat gebruiken om b.v. nog 3 extra gevallen te elimineren.

Idd, maar ik zeg ook niet dat die communicativiteit iets is waarmee je heel het probleem oplost... ik geef verder ook geen uitwerking of iets dergelijks... het is alleen wel iets waarmee je rekening kunt houden, voor het versnellen / vereenvoudigen van je algoritme

[.oisyn]

rwb schreef op 04 november 2003 @ 10:44:
[...]


Hij klopt niet helemaal. Als je 6,6,6,6 invult en zegt dat je alle antwoorden wilt hebben dan vindt hij de volgende

[...]

De eerste 5 zijn exact dezelfde want de haakjes hebben immers geen enkel nut. Anders. En bij 1,3,4 en 5 kan je zelfs de haakjes laten staan en ze zo herordenen dat ze exact hetzelfde zijn. Het haalt tenslotte niet uit of je (6 + 6) + 6 of 6 + (6 + 6) schrijft.



edit:

Overigens niet alleen als je allemaal dezelfde getallen invult. Als je bijvoorbeeld 1,2,3,4 doet krijg je onder andere ook


[...]

Wat natuurlijk ook precies hetzelfde is.

duh, ik ga natuurlijk geen operator semantics inbouwen, dat is ver beyond het scope van het probleem. Dan moet ik helemaal gaan controleren dat + en * commutatief zijn en - en / niet, en dan een analyse doen op de resultaten om vervolgens de dubbele eruit te halen. Ik probeer gewoon alle operatoren met alle mogelijke vormen van haakjes

jvo schreef op 04 november 2003 @ 12:05:
[...]

Misschien is het idee om elke combinatie van operators maar 1 keer voor te laten komen. Dus maar een keer x + x + x + x. Kan iemand een voorbeeld verzinnen waarbij er meerdere verschillende mogelijkheden zijn met dezelfde operators?

iets als + + + wordt sowieso al 1 keer gecontroleerd, het makke zit 'm juist in de combinatie van haakjes die ook allemaal worden geprobeerd. En ja, die maken natuurlijk niet uit als het + + + betreft

mjax schreef op 04 november 2003 @ 08:21:

Jij bent de eerste wie een permutatie-generatie-algoritme gebruikt en dat is zeker de netste en meest flexibele oplossing! Zo op het eerste oog lijkt het trouwens wel wat op Dijkstra's algoritme dat volgens mij ook voor het travelling-salesmen probleem gebruikt wordt. Toeval?

ik denk het, want ik ken dat algoritme niet
Ik heb eerst met de hand een stel permutaties gemaakt, en daarna gekeken wat er nou precies gebeurde. Het is heel makkelijk iteratief te doen aan de hand van de volgorde van elementen. Nadat ik 'm had geimplementeerd bedacht ik me overigens dat er ook zo'n functie voor C++ bestond, en die zat waarempel bijna hetzelfde in elkaar
Wel raar overigens dat php zo'n functie niet kent

[Joove]

Op een gegeven moment heb ik hierover iets gevonden op http://www.reijnhoudt.nl/24game/

[Verwijderd]

.oisyn schreef op 04 november 2003 @ 01:32:
Zo, heb maar even een scriptje geschreven dat alles vind
http://www.oisyn.nl/tests/24game.php

Je kan 'm ook alle mogelijke combinaties laten vinden, maar dat duurt nogal lang, en het script wordt na 30 seconden afgebroken

De source

.edit: zo, even toegevoegd dat je nu het zoeken naar alle mogelijkheden ergens anders kunt beginnen, zodat je nog verder kan als de 30 seconden voorbij zijn

.edit2: zo, wat geoptimized. Nu checkt ie geen dubbele combinaties meer (beetje loos om van bijvoorbeeld 2,2,2,2 24 verschillende combinaties te proberen )
Nu kan ie ze wel allemaal vinden binnen 30 seconde

offtopic:
zou je me kunnen uitleggen wat dit precies doet?

PHP:

        for ($o = 0; $o < 64; $o++)
        {
            $o1 = $operators[$o & 3];
            $o2 = $operators[($o >> 2) & 3];
            $o3 = $operators[($o >> 4) & 3];

wat doen die $o & 3 bijvoorbeeld bij $o1 en die >> bij $o2 en $o3?

[.oisyn]

Oh, dat is een stukje bit hack werk. Je hebt 4 verschillende operators, en die gebruik je 3 keer. Ik kan dan wel 3 loopjes van 0 tot 4 maken, maar ook gewoon 1 loopje van 0 tot 64 (scheelt een hoop lelijke nesting )

Je kunt het zien als getallen die zijn opgebouwd uit cijfers. Stel er waren 10 operators, dan kon ik een lusje van 0 tot 1000 maken, en elke cijfer in dat getal stelt dan een operatornummer voor.

Hier hetzelfde, maar de 'cijfers' lopen van 0 t/m 3 ipv 0 t/m 9. En aangezien 4 een macht van 2 is, kun je met bitoperaties gemakkelijk de losse bits eruit halen. De eerste 2 bits zijn voor de eerste operator, de volgende 2 voor de 2e operator, en de 2 daarna voor de 3e. Met de & blijven alleen die bits 'aan' staan die je aangeeft (3 is 11 binair). De shift wordt gebruikt om het 2e en 3e groepje van 2 bits naar voren te schuiven

[Grijze Vos]

Ik heb niet alles doorgelezen, dus mijn excuses als iets in deze richting al gepost is.

Een maat van mij heeft in assembly voor de Ti-83 plus graphische rekendoos eenzelfde game gemaakt. En hij heeft zo'n algoritme geimplementeerd, ja, het is dus mogelijk.

Hoe is hij te werk gegaan. Met een recursieve functie. Die van elke 2 variabelen, alle mogelijke nieuwe getallen uitrekent. En met dat voor alle getallen. Vervolgens doe je hetzelfde voor de 3 getallen die je dan overhoudt (dus alle nieuwe getallen, en de overige twee getallen die je als invoer hebt staan nog). Zo ga je doorgraven totdat je alle mogelijke combos hebt gehad.

Tis even puzzelen en nadenken, maar dat mag je zelf doen. Is een leuke wiskundige uitdaging.

[X-G]

Grijze Vos schreef op 06 november 2003 @ 00:29:
Ik heb niet alles doorgelezen, dus mijn excuses als iets in deze richting al gepost is.

Een maat van mij heeft in assembly voor de Ti-83 plus graphische rekendoos eenzelfde game gemaakt. En hij heeft zo'n algoritme geimplementeerd, ja, het is dus mogelijk.

Hoe is hij te werk gegaan. Met een recursieve functie. Die van elke 2 variabelen, alle mogelijke nieuwe getallen uitrekent. En met dat voor alle getallen. Vervolgens doe je hetzelfde voor de 3 getallen die je dan overhoudt (dus alle nieuwe getallen, en de overige twee getallen die je als invoer hebt staan nog). Zo ga je doorgraven totdat je alle mogelijke combos hebt gehad.

Tis even puzzelen en nadenken, maar dat mag je zelf doen. Is een leuke wiskundige uitdaging.

Ik dacht dat al die GR's met een speciale vorm van BASIC werkten?
Mijn Casio CFX-9850GB Plus wel iig.

[RayNbow]

X-G schreef op 06 november 2003 @ 12:02:
[...]

Ik dacht dat al die GR's met een speciale vorm van BASIC werkten?
Mijn Casio CFX-9850GB Plus wel iig.

offtopic:
De TIs hebben TI-BASIC, maar ze kunnen ook assembly progs draaien. De TI-83 heeft een Z80 processor. Voor meer info, zie www.ticalc.org

[Verwijderd]

webfreaky had zeker moeite vroeger met de flippo's en wil nu zeker wraak nemen?
als je er eerder mee was gekomen had je nog prijzen kunnen winnen toen flippo's nog in waren
maar op zich is het idee wel leuk

[Verwijderd]

Verwijderd schreef op 03 november 2003 @ 22:35:
Er zit nog ergens een foutje in, ik ben ermee bezig

als iemand weet hoe je hier 24 van maakt (kan niet volgens mijn script, wel volgens smiths, nu lays:

7, 3, 3, 5

geblaat...

[ Voor 13% gewijzigd door Verwijderd op 06-11-2003 14:59 ]

[Verwijderd]

Verwijderd schreef op 06 november 2003 @ 14:57:
[...]


Weet niet of het antwoord er stiekem al was, maar zie hier:

(3+5) * (7-3)

?

8 * 4 is nog altijd 32