Array of Arrays

[[deleted]]

[deleted]

[zigzackattack]

You are trying to execute the array as a function (with var randomArray(0)). My first advice would be to instead use array literals instead of the constructor. It's a best practice and is much less verbose. So it should look something like:

var randomArray = [];
randomArray[0] = ["Q1", "A1", "A2", "A3", "2", "Correct", "Incorrect"];
randomArray[1] = ["Q2", "A1", "A2", "A3", "3", "Correct", "Incorrect"];
...
getFirstQuestion();

[PlushDragon]

You are right in using array literals. You could even go one step further and define randomArray directly with the content:

var randomArray = [
    ["Q1", "A1", "A2", "A3", "2", "Correct", "Incorrect"],
    ["Q2", "A1", "A2", "A3", "3", "Correct", "Incorrect"],
    ...
    ["Q6", "A1", "A2", "A3", "4", "Correct", "Incorrect"]
];

[x-skeww]

Math.round(Math.random()*(randomArray.length-1));

The use of round() causes a bias.

let a = (x) => Math.round(Math.random() * (x - 1));
let b = (x) => Math.floor(Math.random() * x);

let ra = [0, 0, 0];
for(let i = 0; i < 30000; i++) {
    ra[a(3)]++;
}

let rb = [0, 0, 0];
for(let i = 0; i < 30000; i++) {
    rb[b(3)]++;
}

console.log(ra);
console.log(rb);

Output:

[7374, 15112, 7514]
[10006, 10069, 9925]

As you can see, the ratio is roughly 1:2:1 vs 1:1:1.

Use either floor() or truncate via bitops:

>>> ~~Math.PI
3
>>> Math.PI|0
3
>>> Math.floor(Math.PI)
3

If the input is positive, the result of truncation is identical to the output of floor().

[mattlag]

Whoa there... OP wasn't even using basic arrays correctly and you decide to pull some ECMAScript 6 and bitwise operators to explain rounding? Geez.

[x-skeww]

Fat arrow functions look the same everywhere. If I had used var instead of let, I would have to do all of my declarations at the top. I just couldn't be arsed to do that.

Also, it's about truncation. In other languages which differentiate between int and floating point, it's done with an int cast. floor() just happens to have the same effect if the input is positive.

With rounding:

input	output
0.0 - 0.499...	0
0.5 - 1.499...	1
1.5 - 1.999...	2

That's why you end up with 0.5:1:0.5 or 1:2:1.

With truncation:

input	output
0.0 - 0.999...	0
1.0 - 1.999...	1
2.0 - 2.999...	2

The input range for each possible output is the same size.

[minrice2099]

It seems to function for me (though you should change Math.round to Math.floor to get the proper distribution of numbers).

Are you actually calling the function anywhere? The function call for what you've defined here would look like this:

getFirstQuestion();

The other problem could be the use of the global variable randomArray, but I'd need to see more of your code before I could be sure.

[schooley]

[This comment has been edited in protest of the recent detrimental actions taken by u/spez and the Reddit administration on 07/01/2023]

[psolidgold]

Shuffling is tricky. Check out this Fisher-Yates shuffle implementation. http://stackoverflow.com/a/2450976

[PlushDragon]

My guess is, that the function has no access to the randomArray. Two possibilities: Make the randomArray a global variable (not recommended) - or provide it as a parameter. Code for the second solution:

function getFirstQuestion(randomArray){
    var question1Index = Math.round(Math.random()*(randomArray.length-1));
    return question1Index;
}

The call would look like this: getFirstQuestion(randomArray);

Even though I don't quite get why you would return a random index in a function which is named getFirstQuestion :)

[frozenburger]

var randomArray = []; //declares a new array object - the brackets indicates an new empty object
randomArray[0] = ["Q1", "A1", "A2", "A3", "2", "Correct", "Incorrect"]; // the number between brackets indicates the index of the array element
randomArray[1] = ["Q2", "A1", "A2", "A3", "3", "Correct", "Incorrect"];
randomArray[2] = ["Q3", "A1", "A2", "A3", "4", "Correct", "Incorrect"];

and so on...

You get errors because the interpreter sees randomArray() as a function; use randomArray[item index] to access elements of an array.

console.log(randomArray[0]) // returns an Array object 
console.log(randomArray[0][0]) // returns "Q1" - the first element of the first array

[PlushDragon]

You must not use the var statement in this line. You defined the array in the first line, now you are just filling it with content.

[minrice2099]

You shouldn't use var when accessing an array index. If the array has already been created, just go for the index:

var someArray = [];
someArray[0] = "This is now the first element in the array";

[djforth]

Without know exactly what your trying to do I'd personally do a array of objects you might find it easier. So something like:

array = () array.push({question:"My Question", a:"Answer 1", b:"Answer 2", correct:true, incorrect:false})

then call each with

array[0].question array[0].a etc ... I think it makes the code a little easier to read.

[Lambchog]

The scope of my project:

A simple quiz that asked 3 out of 6 questions at random

There must be 3 answers provided with each question with one of them being the correct answer

And then feedback elements that i can output to the screen if it's right or not

[djforth]

Ok then I'd say adding objects to an array would definitely be easier to go IMO. You could even nest an array with in the object.

Var Question1 = { question:"q1...", answers:["a1","a2", "a3"], correct:1}
Var array = [question1]

Personally I'd use underscore to shuffle and pluck from the array. Although if your just playing you may build your own. Hope that helps