24数学ゲーム - Javascriptの乱数ジェネレータとソルバー

Question

JavascriptでGame 24のナンバージェネレータを作成するにはどうすればよいですか？ 乱数ジェネレータは、24を解決できる数だけ生成する必要があります。問題を解決できる数だけ生成してください。ゲームの

ルール：

あなたは4つの数字を取得します。あなたは24を作るために必要なことはでき+、X、 - およびそれらの数字は取得するには％24

例：4、2、8、1

（（4-2）+ 1）×8 = 24

乱数生成器はあなたに4つの数字を与える必要がありますあなたは24をすることはありません任意の番号を取得してはならない24を占めるようになる、例1,1,1および2

のために私が唯一にしたいです整数を使用する。

私は少しゲームを変更したいと思います。常に24を使用するのではなく、初心者の場合は12、上級者の場合は55など、別の番号を使用したい場合があります。

私は初心者です。どんな説明も素晴らしいだろう。

Answer 1

このバイオリンは、何らかの形で与えられた数のアップが追加できる一連の番号を取得するための方法を示しています

jsFiddle

これは私が単に合計ので、「ランダム」番号を取得する簡単な方法です私のランダムな操作と最後に1つの制御された操作を挿入して、必要なターゲットを生成できることを確認します。

私はリンクをたどるしたくないあなたの人々のために、以下のソースコードをダンプします：

console.clear(); 
function getNumberGame(target, length) { 
    console.clear(); 
    var dataset = []; 
    var methods = { 
     'add' : function (a, b) { 
      return (a + b); 
     }, 
     'subtract' : function (a, b) { 
      return a - b; 
     }, 
     'multiply' : function (a, b) { 
      if (a !== 0 && b !== 0 && a < Infinity && b < Infinity) { 
       return Math.round(a * b); 
      } else { 
       return false; 
      } 
     }, 
     'divide' : function (a, b) { 
      if (a !== 0 && b !== 0 && a < Infinity && b < Infinity) { 
       return Math.round(a/b); 
      } else { 
       return false; 
      } 
     } 
    } 
    for (var i = 0; i < length - 1; i++) { 
     var obj = { 
      value : Math.round(Math.random() * target) + 1, 
      method : Object.keys(methods)[Math.floor(Math.random() * Object.keys(methods).length)] 
     }; 
     dataset.push(obj); 
    } 
    delete dataset[0].method; 
    var data = dataset[0].value * 1; 
    console.log('Start with ' + data); 
    for (var i = 1; i < dataset.length; i++) { 
     data = methods[dataset[i].method](data, dataset[i].value); 
     console.log(dataset[i].method + " " + dataset[i].value + " to get " + data); 
    } 
    if (data > target) { 
     dataset.push({ 
      value : Math.round(Math.abs(data - target)), 
      method : 'subtract' 
     }); 
     console.log("subtract " + dataset[dataset.length - 1].value + " to get " + target); 
    } else if (data < target) { 
     dataset.push({ 
      value : Math.round(Math.abs(data - target)), 
      method : 'add' 
     }); 
     console.log("add " + dataset[dataset.length - 1].value + " to get " + target); 
    } 
    var returnArray = []; 
    while (dataset.length > 0) { 
     var i = Math.floor(Math.random() * dataset.length); 
     returnArray.push(dataset[i].value); 
     dataset.splice(i, 1); 
    } 
    console.log(returnArray); 
    alert("Make \"" + target + "\" by combining these " + length + ":\n" + returnArray.join(', ')); 
    return returnArray; 
} 

getNumberGame(parseInt(prompt("Target number", 24)), parseInt(prompt("Steps", 4))); 

InfinityまたはのためのチェックがないことをEDIT 1

注意0のmultiplyとdivideの機能が異常に動作する可能性があります。私のコードは、このような状況では0（返されるのはfalse）を返すだけです。

Answer 2

使用この1と現在skillLevel間の乱数を生成する：skillLevelは24、55または何である

var skillLevel = getCurrentSkillLevel(); // get skill level in any way you seem appropriate. 

function getRandomInt(skillLevel) { 
    return Math.floor(Math.random() * skillLevel) + 1; 
} 

。

Answer 3

You must not get any numbers that will not make 24. 

実際には、この文はソルバーを実装する必要があることを意味していますが、これは非常に困難です。一般的なアプローチは、すべての可能な組み合わせを試みることであり、そのためにはbacktrackingがよく使用されます。

大括弧で囲みますと、このアルゴリズムを実装するのが非常に難しくなりますが、それはまた素晴らしいチャレンジになる可能性があります。私はSUDOKU solverで始めることをお勧めします。これは一般的に実装が簡単で、バックトラックのようなものです。

Answer 4

EDIT：下にオリジナルテキストがあります。

わかりました。私はそれをしました。私はコードがどれほど大変なのか誇りに思っていません。それは約千の場所でより効率的にできると確信していますが、機能します。

//[A,B,C,D] 

var skillLevel = 24; 
numbers = []; 
for (i=0;i<=3;i++){ 
    numbers[i] = (Math.floor(Math.random() * skillLevel) + 1); 
} 
function permutateOperations(numberArray){//This function, given an array of the form [A,B,C,D] where ABCD are numbers, places operations [+,-,*,%] between the numbers in the array 
var possibilities = []; 
var splicednumbers = numberArray.slice(); 
var operations = ['+','-','*','%']; 
    for (var j=0;j<=3;j++){//[A,j,B,k,C,m,D] 
     for(k=0;k<=3;k++){ 
      for(m=0;m<=3;m++){ 
       splicednumbers.splice(3,0,operations[m]); 
       splicednumbers.splice(2,0,operations[k]); 
       splicednumbers.splice(1,0,operations[j]); 
       possibilities.push(splicednumbers); 
       splicednumbers=numberArray.slice(); 
      } 
     } 
    } 
    return possibilities; 
} 

function permutateNumbers(numberArray){//This function, given an array of the form [A,B,C,D], returns an array of arrays that have all the possible orderings 
var possibility = []; 
var possibilities = []; 
var remainingArray=[]; 
var splicednumbers = numberArray.slice(); 
for (var i=0;i<=3;i++){ 
    threeRemain = splicednumbers.slice();//[A,B,C,D] 
    possibility[0]=splicednumbers.splice(i,1)[0]; 
    for(var j=0;j<=2;j++){ 
     twoRemain=splicednumbers.slice();//[A,B,C] 
     possibility[1]=splicednumbers.splice(j,1)[0]; 
     for(var k=0;k<=1;k++){ 
      oneRemain = splicednumbers.slice(); //[A,B] 
      possibility[2]=splicednumbers.splice(k,1)[0]; 
      for(var m=0;m<=0;m++){ 
       possibility[3]=splicednumbers.splice(m,1)[0]; //[A] 
       possibilities.push(possibility.slice()); 
      } 
      splicednumbers=oneRemain.slice(); 
     } 
     splicednumbers=twoRemain.slice(); 
    } 
splicednumbers=threeRemain.slice(); 
} 
return possibilities; 
} 

function permutateParenthesis(operationArray){//I AM SORRY THIS IS AWFUL BUT I COULDN'T THINK OF ANYTHING ELSE 
//Given an array like [A,&,B,&,C,&,D], where ABCD are numbers and & is any operation, returns the 5 possible arrays that result from having parenthesis in different positions within it. 
    saved = operationArray.slice(); 
    //[A,&,B,&,C,&,D] 
    permutations = []; 
    //First option 
    operationArray.splice(0,0,"("); 
    operationArray.splice(4,0,")"); 
    permutations.push(operationArray.slice()); 
    operationArray = saved.slice(); 
    //Second option 
    operationArray.splice(0,0,"("); 
    operationArray.splice(3,0,")"); 
    operationArray.splice(4,0,"("); 
    operationArray.splice(10,0,")"); 
    permutations.push(operationArray.slice()); 
    operationArray = saved.slice(); 
    //Third option 
    operationArray.splice(0,0,"("); 
    operationArray.splice(6,0,")"); 
    permutations.push(operationArray.slice()); 
    operationArray = saved.slice(); 
    //Fourth option 
    operationArray.splice(2,0,"("); 
    operationArray.splice(7,0,")"); 
    permutations.push(operationArray.slice()); 
    operationArray = saved.slice(); 
    //Fifth option 
    operationArray.splice(4,0,"("); 
    operationArray.splice(8,0,")"); 
    permutations.push(operationArray.slice()); 
    operationArray = saved.slice(); 

    return permutations; 
} 
finalnumbers = permutateNumbers(numbers); 
operationNumbers = []; 
for (i=0;i<finalnumbers.length;i++){ 
    operationNumbers.push(permutateOperations(finalnumbers[i])); 
} 
parenthesisNumbers=[]; 
//Showtime 
for (var j=0;j<operationNumbers.length;j++){ 
    for (var k=0;k<operationNumbers[j].length;k++){ 
     parenthesisNumbers.push(permutateParenthesis(operationNumbers[j][k])); 
      if (eval(operationNumbers[j][k].join(""))===24){//get a string with the finished combination, eval it to perform the operation, see if it is 24 
      console.log(operationNumbers[j][k].join("") + " Is valid"); 
      } 
    } 
} 

ORIGINAL：

私はここでほとんどの人が問題を欠けていると思います。

ここで問題となるのは、24以下の乱数を生成しないことです（これは、あなたがする必要のあるものでもありません）。[50,6,6,2]の数字が6 * 2 *（50％6）=あなたが上限を必要とすると思います。）

ここで問題となるのは、4つの数字を取得した後、それらをチェックすることです。それは、操作の組み合わせを考えれば24になる可能性があります。

あなたは[+、 - 、*、％]と4つの数字[A、B、C、D]の4つの操作を持っています。これらの2つのセットのすべての組み合わせをチェックする必要があります。 4 + 4 * 4（[+、+、+、+]のすべての組み合わせを実行することを意味するので、 - 、*、％]）は、[A、B、C、D]、4 * 3 * 2 * 1の可能な組み合わせのそれぞれについてチェックします。

次に、posisbilitiesをもう少し乗算する括弧を考慮しなければなりません。

私はイニシアチブに拍手を送っています。興味深い問題だと思いますが、ここでlibikに同意するつもりです。あなたが望むのは、javascriptを学ぶのが簡単なことです。

あなたが正しい方向を指していることを願ったら、私ができるなら助けてくれることを喜んで喜んでいます。私はそれが面白い問題だと思うので正直にそれを解決しようとするかもしれません。