I got this grid with each square's index showing in the middle (0-63):
Then I have a function which needs to return the row number when I pass it an index.
The row number can be between 0-7.
Function that should do this, with a poor attempt at retrieving the row number currently inside it:
function (index) {
return Math.floor(index / 7);
}
Example outputs (index -> row output):
0 -> 0
5 -> 0
7 -> 0
8 -> 1
23 -> 2
35 -> 4
43 -> 5
63 -> 7
I looked at this question which I thought was about the same issue as I'm having but the answer there did not give the correct output so I must've misunderstood it.
How can I change my function to return the correct row number from a given index?
You need to divide by column count which are 8:
function (index) {
return Math.floor(index / 8);
}
I'm learning about Javascript arrays. I understand most of the code, except line 4. Can you please explain what the code in line 4 does, and how it has this output.
var fibonacci = []; //{1}
fibonacci[1] = 1; //{2}
fibonacci[2] = 1; //{3}
for(var i = 3; i < 20; i++){
fibonacci[i] = fibonacci[i-1] + fibonacci[i-2]; ////{4}
}
for(var i = 1; i<fibonacci.length; i++){ //{5}
console.log(fibonacci[i]); //{6}
}
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
Thank you.
it's Fibonacci sequence. How it works? every number after the first two is the sum of the two preceding ones that's why you have to initialize the first two terms
fibonacci[1] = 1;
fibonacci[2] = 1;
on line 1 you create the array and after intializing the first two terms you loop, starting from the third index var i = 3 to fill the array fibonacci with all the terms of the sequence. How? it assigns the sum of the two previous terms to the current one.
ps: in javascript arrays start at index 0
At Line 2 & 3 you set the values for item 1 & 2. Since fibonacci is sum of two values before, the line 4 just sums up the two values before for each element from 3 to 19.
I just completed some form of a competency exam for a programming school, and I got every question correct except this, although it appears really quite easy, yet I couldn't get it. Any ideas?
Observe the code below.
var x = [1,5,7,13];
for(i=0; i < x.length; i++)
{
x[i] = x[3-i] + 2;
}
Once the program is done, what would be in x?
a [3,7,9,15]
b [15,9,11,3]
c [15,9,7,3]
d [15,9,11,17]
The answer is d
first loop
x[0] = 13 + 2 = 15
second loop
x[1] = 7 + 2 = 9
third loop
x[2] = 9 + 2 = 11
fourth loop
x[3] = 15 + 2 = 17
x = {15, 9, 11, 17}
To figure this out, you'll have to understand that x[] is used to refer to a specific index of the array. For example:
var x = [5,6,7];
In this case, x[0] would be equal to 5, assuming a 0-index based array.
Knowing this, let's break down your loop. We'll start by filling in the variable name instead of the variable value step by step, to leave out confusion of following variables in your head.
var x = [1,5,7,13];
for(0=0; 0 < x.length; 0++)
{
x[0] = x[3-0] + 2;
}
For the first iteration, everything starts to become a little clearer as you can tell that now it's setting x[0] (the first value in the array) to equal x[3-0] (which would be x[3], which in turn would be 13 due to the 0-index array), plus 2. 13 + 2 = 15. The first number is 15.
var x = [1,5,7,13];
for(1=1; 1 < x.length; 1++)
{
x[1] = x[3-1] + 2;
}
Let's try one more! x[3-1] is the same as x[2] which is 7; 7 + 2 = 9. Your second number is 9.
Following the same logic you can see how the loop functions and understand how it's referencing the array's values.
The key here is that you're updating the same array you're reading from as you go through it. (Note: generally I'd consider this bad practice and I've seen a lot of programmers fall into this trap - it's very easy to misunderstand the code).
First thing to realize is that x[3-i] basically reads the opposite end of the current index. To be more generic, it should really have been x[(x.length-1)-i] but the 3 is hardcoded in this case.
Now, the first round is easy: 13+2 = 15. 13 because the opposite end of the first element is the last element:
x = [15,5,7,13]
▲ │ this+2
└──────┘
In the second round we replace 5 with 7+2 = 9:
x = [15,9,7,13]
▲ │ this+2
└─┘
In the third round we find ourselves doing something not initially obvious. Instead of replacing 7 with 5+2 we replace it with 9+2 instead because we've already replaced 5 with 9:
x = [15,9,11,13]
│ ▲
this+2 └─┘
Now finally we replace the last element with 15+2 using the same reasoning above:
x = [15,9,11,17]
│ ▲
└───────┘
this+2
I have been trying to populate an array using a for loop and taking such values using document.getElementById("spin " + i).value;
The ids on my html for every input tag go from spin1 to spin18.
Any suggestions on what I am doing wrong? Or what I can change?
var nums = [];
for(var i = 1; i <= 18; i++){
var num[i] = parseInt(document.getElementById("spin" + i).value);
nums.push(num[i]);
}
alert(nums.length);
What is the problem? You never mention what kind of results being generated or what the front-end html code looks like.
The js looks compilable, but here are some pointers.
The number 0 is before 1
It's a good habit to get in this mind set, plus it might save you from making stupid mistakes later on. Anyway, just to reinforce this, below is a number chart.
0 10
1 11
2 12
3 13
4 14
5 15
6 16
7 17
8 18
9 19
Avoid unnecessary variables
Having a js compiler that optimizes redundant code is sadly new feature. But still, why have two lines to maintain when you can have one.
var nums = [];
for( var i = 0; i < 18; i++ ) {
nums[i] = parseInt( document.getElementById("spin" + i).value );
}
Don't push, insert
The push method has an expensive overhead so use it with caution.
Loggers
The console has a built in logger, why not use that instead of an alert box?
console.log( nums.length );
try this
var nums = [];
for(var i = 1; i <= 18; i++){
var num= parseInt(document.getElementById("spin" + i).value);
nums.push(num);
}
alert(nums.length);
A couple of things to note:
As PSR has mentioned, you use:
var num[i]
when it should be
var num
getElementById(id).value only works for form elements, you have to use .innerHTML for divs.
This works for me: http://jsfiddle.net/sbqeT/
I want to record the time between each keystroke (just one key to start with, the 'A' key) in millseconds.
After the user finishes his thing he can submit and check out the timings between each key stroke. Like:
1: 500
2: 300
3: 400
4: 500
5: 100
6: 50
7: 50
8: 25
I believe this is possible with Javascript, is it?
Sure:
var times = [];
// add an object with keycode and timestamp
$(document).keyup(function(evt) {
times.push({"timestamp":evt.timeStamp,
"keycode":evt.which})
});
// call this to get the string
function reportTimes() {
var reportString = "";
for(var i = 0; i < times.length - 1; ++i) {
reportString += (i+1) + ": " + (times[i+1].timestamp - times[i].timestamp) + " ";
}
return reportString; // add this somewhere or alert it
}
I added the keycode just in case you wanted it later; it's not necessary for your exact problem statement.
Clarification from comments discussion:
The for loop only goes to up to times.length - 2 (since i is always strictly less than times.length - 1), so there is no issue about times[i+1] being outside the bounds of the array. For example, if you do five key presses and therefore have a times array with five elements (indexed from 0 to 4):
1st pass: times[1].timestamp - times[0].timestamp
2nd pass: times[2].timestamp - times[1].timestamp
3rd pass: times[3].timestamp - times[2].timestamp
4th pass: times[4].timestamp - times[3].timestamp
Then the loop terminates, because setting i to 4 triggers the termination condition:
= i < times.length - 1
= 4 < 5 - 1
= 4 < 4
= false [i cannot be set to 4 by this loop]
Thus, times[i+1] is always a validly indexed element, because i is at most one less than the maximum index.