I want to be clear about this interpretation.

yes there is a chance that it could be guessing a single number multiple times, but with a range from 1 - 10000 it will be highly uncommon. also, to create a function that then has to compare each guess to all of its previous guesses would actually be slower, think if we ran the random number function to guess, and it guessed say 22, on its 3000th guess, it would have to compare 22 to an array of all 3000 guesses (thats a lot) then say it finds it has already guessed 22...well i guess we'll just ignore that guess? right a function like that would be paradoxical because the guess function has to fire before it can know if it already guessed that number. see what I'm saying? it actually faster to just brute force guess numbers regardless of if they've been guessed already.

to add to the point, random numbers aren't really random, they're pseudo-random, meaning the computer took a seed (say the current time) and ran it though a calculation to give the "random" number.

Daniel, you're absolutely right that the number of guesses can be more than the range of numbers due to duplicate guesses. But Zach also has a good point about how not to attempt to avoid them. So to efficiently guess without duplication requires a different strategy.

One way would be to create an array with a "pool" of potential guesses. Then each time you randomly choose an item from the pool and it is incorrect, you discard it and reduce the size of the pool. That way you can guarantee that the number of guesses will always be less than or equal to the total range, and every guess will require only one random choice.

var upper = 1000; 
var randomNumber = getRandomNumber(upper);
var attempts = 0;

function getRandomNumber(upper) {
  return Math.floor( Math.random() * upper ) + 1;
}

var pool = [...Array(upper+1).keys()];   // create the guessing pool
pool.shift();                            // but without 0

function nextGuess() {
  var ix = getRandomNumber(pool.length); // get a random guess
  return pool.splice(ix-1,1)[0];         // remove it from the pool
}

while (nextGuess() != randomNumber) {
  attempts += 1;
}

document.write(`Computer took ${attempts}
attempts to guess the number: ${randomNumber}`);

Hi guys, thanks for your answers but i think you can just add a line of code and make it a lot more faster. so instead of calling a function we just add += to guess number so each time the computer will try a bigger number until he finds it.

so is not need for an array or a big solution because we no need the old numbers we just need to make sure that we try them all.

please let me know what you think.

var upper = 1000; 
var randomNumber = getRandomNumber(upper);
var guess = 0;
var attempts = 0;

function getRandomNumber(upper) {
  return Math.floor( Math.random() * upper ) + 1;
}


while (guess !== randomNumber) {
  attempts += 1;
  guess += 1; 
}

document.write(" Computer took " + attempts + 
" attempts to guess the number: " + randomNumber);

yes you can remove guess variable for attempts they have the same value, , and I agree that the propose of the exercise was the random numbers, my analysis was more for the fun of make it more efficient and practice my new knowledge. you are right about some times could be less faster than random but is guaranteed no bigger than the total numbers. so at the end you get a more efficient program (at least i think so lol).

so the question now is, is the program more efficient like this than with the random guessing? :)

Thanks!

You could try implementing both ideas side by side and see which is more effecient.

Both methods average 500 guesses (half the range) to get the number, but the sequential method is much faster since it is essentially just a counter.

It can be made much faster still by maintaining just one counter:

do {
  attempts += 1;
} while (attempts < randomNumber);