foreach(split(parseBin(parseAscii(password()))));

Ranzear fucked around with this message at 03:17 on Oct 8, 2017

function getPassword() {
	// Your instructor is here trying (but failing) to use something called "Hungarian Notation"
  // ([url]https://en.wikipedia.org/wiki/Hungarian_notation[/url]) for these variable names. This notation means
  // that when the variable is an integer (a whole number) it's name should start with 'int'.
  // I say they are failing at this because clearly all of these variables are strings
  // (sequences of alphanumeric characters), not integers.
  var intDefLetter = "C";
  var intQuestion = "Arrr I got a message I can give, do ye have the password?";
	var intNewLetter = "";

	// This is a very obscure and totally unused feature built in to web browsers that displays a dialog box
  // that allows the user to enter input ([url]https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt[/url]).
  // It will (for some reason) display a 'C' in the dialog box as the default input because of the
  // variable above (intDefLetter).
  intNewLetter = prompt(intQuestion, intDefLetter);

	// This checks whether the user has entered more than one letter in the dialog box mentioned above,
  // and if they did then it opens the same dialog box again.
	if (intNewLetter.length > 1) {
  	prompt(intQuestion, intDefLetter);
  }

	// This returns whatever was last entered in the dialog box from this function.
	return intNewLetter;
}

// Every character that can be entered via the keyboard can be represented by a number and the number for
// each character (in this function) is determined by a protocol called ASCII ([url]https://en.wikipedia.org/wiki/ASCII[/url])
// which is why the this function is named 'parseASCII' however it is extremely dumb because you can simply use
// 'charCodeAt' in your own code any time so this function is pointless.
// For example:
// var intASCIICodeOfA = "A".charCodeAt(0);
function parseAscii(intNewLetter) {
	var intAscii = "";
	intAscii = intNewLetter.charCodeAt(0);

	return intAscii;
}

function parseBin(intAscii) {
	// Here again your instructor is trying to use Hungarian Notation and they are at least somewhat more successful
  // this time. This variable name is supposed to be an abbreviation for "string binary". There is no such thing so
  // again that's why I say they are still unsuccessful. Really this variable is, again, just a string.
  var strBin = "";

	// This finds the base two ([url]https://en.wikipedia.org/wiki/Binary_number[/url]) representation of the ASCII code
  // (which is an integer) of the character entered by the user in the dialog box originally.
	strBin = parseInt(intAscii, 10).toString(2);

	// Here the idea is to create a byte ([url]https://en.wikipedia.org/wiki/Byte[/url]) from the base two (binary) representation
  // of the ASCII code derived above from the character that the user entered in the dialog box.
 
  // This loop is required because a byte is eight bits (a bit is a one or a zero) long. Therefore if the base two
  // representation of the character entered is less than eight characters we need to add enough characters that we
  // can create a byte (get up to eight bits).
  if (strBin.length < 8) {
    var intPlaceHolders = 8 - strBin.length;	// This determines how many characters we have to add to have a byte.

    for (var i = 0; i < intPlaceHolders; i++) {
      strBin = "0" + strBin;	// Add a zero on to the 'front' of the string.
    }             
  }

  return strBin;	// Return the string that represents the byte.
}

// Here again, bizzarely, your instructor is pointlessly wrapping a standard built in Javascript function available
// everywhere in your own code with another function. You can simply call "split" on any string any time in your code.
// The split function is called on a string and splits it into multiple strings (inside an array) at every point that
// the separator you send exists, for example:
// var arrayFromAString = "one,two,three".split(','); // returns an array with three elements: ['one', 'two', 'three']
function split(strBin) {
	var strMessage = "";

  strMessage = strBin.split("");  

  return strMessage;
}

// Your instructor has a truly weird habit of writing new functions named identically to existing built in
// (to the browser environment) Javascript functions. The 'forEach' function exists in the prototype of the Array
// object ([url]https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach[/url]).
function forEach(strMessage) {
  var arrayLength = strMessage.length;
  var i;

	for (i = 0; i < arrayLength; i++) {
  	// THE FOLLOWING IS COMPLETELY BROKEN: it's supposed to read "strMessage[0] == 0" which would determine if the first
    // character in the passed string (strMessage) is zero, however what this code actually does is always return the Boolean value
    // 'false' because it is making the first character of the passed string zero. Whenever you assign a value to a variable using
    // the equals operator ("=") that expression returns the assigned value which in this case is a zero and a zero in Javascript
    // is "falsy" ([url]https://developer.mozilla.org/en-US/docs/Glossary/Falsy[/url]) meaning it will evaluate to the Boolean value 'false'.
    // This means that this block of code will never execute.
  	if (strMessage[i] = 0) {
  		var falseOutput = document.getElementById("message"); 
    	var msgFalse = "False ";     

      falseOutput.textContent = msgFalse;
    // This block of code will always execute (see comment above).
  	} else {
    	// This is simply finding the part of the webpage this code is executing on with the ID "message" and placing the text "True "
      // inside of that element. As noted above this code is basically broken so this will happen no matter which single character is
      // entered in the initial dialog box.
			var trueOutput = document.getElementById("message");
  		var msgTrue = "True ";

 	    trueOutput.textContent = msgTrue;
    }
  }
}

// I have renamed these functions to make some kind of sense.
var password = getPassword();
var ASCIIPassword = parseAscii(password);
var binaryStrPassword = parseBin(ASCIIPassword);
var splitBinaryPassword = split(binaryStrPassword);
forEach(splitBinaryPassword);

Dogcow fucked around with this message at 05:39 on Oct 8, 2017

    // This is a very obscure and totally unused feature built in to web browsers that displays a dialog box
  // that allows the user to enter input ([url]https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt[/url]).
  // It will (for some reason) display a 'C' in the dialog box as the default input because of the
  // variable above (intDefLetter).
  intNewLetter = prompt(intQuestion, intDefLetter);

    // This checks whether the user has entered more than one letter in the dialog box mentioned above,
  // and if they did then it opens the same dialog box again.
    if (intNewLetter.length > 1) {
  	prompt(intQuestion, intDefLetter);
  }

let newLetter = '';

while (newLetter.length !== 1) {
  newLetter = prompt(question, 'C');
}

Nolgthorn fucked around with this message at 17:48 on Oct 8, 2017

/**
 * Show the user a prompt and get exactly n letters from it.
 * @param {number} desiredLength
 * @return {string}
 */
function getPassword(desiredLength) {
  const defaultLetter = "C";
  const question = "Arrr I got a message I can give, do ye have the password?";
  let newLetter = "";

  while (newLetter.length !== desiredLength) {
    newLetter = prompt(question, defaultLetter);
  }

  return newLetter;
}

/**
 * Take a number and return the binary string representation of it. Assumes that
 * the number is at most 128 (the upper end of the ASCII range). This will break
 * if given the char code of a letter with diacritics or other special stuff!
 * @example ```js
 *   console.log(parseBin(92)); // logs "01011100"
 * ```
 * @param {number} charCode
 * @return {string}
 */
function charCodeToBinaryString(charCode) {
  const binaryString = parseInt(charCode, 10).toString(2);
  return "0".repeat(8 - binaryString.length) + binaryString;
}

/**
 * Given an array of "1" and "0" values, change the text of the `#message`
 * element on the page based on each one.
 * @example ```js
 *   checkBinaryString(["1", "0", "1", "0"]); // `#message` will end up `false`
 * ```
 * @param {string[]} binaryString
 * @param {HTMLElement} outputElement
 */
function checkBinaryString(binaryString, outputElement) {
  binaryString.forEach(value => {
    outputElement.textContent = value === "0" ? "False" : "True";
  });
}

/**
 * @param {HTMLElement} outputElement
 */
function getAndParsePassword(outputElement) {
  const password = getPassword(1);
  const ASCIIPassword = password.charCodeAt(0);
  const binaryStrPassword = charCodeToBinaryString(ASCIIPassword);
  const splitBinaryPassword = binaryStrPassword.split("");

  checkBinaryString(splitBinaryPassword, outputElement);
}

getAndParsePassword(document.getElementById("message"));

const LENGTH = 1
const DEFAULT_ANSWER = 'C'
const QUESTION = 'Arrr I got a message I can give, do ye have the password?'

/**
 * Show the user a prompt and get exactly `length` letters from it.
 * @param {number} length
 * @param {string} defaultAnswer
 * @param {string} question
 * @return {string}
 */
function getLetter(length, defaultAnswer, question) {
  const letter = prompt(question, defaultLetter)
  return letter.length === length
    ? letter
    : getLetter(length, defaultAnswer, question)
}

/**
 * Return the last bit of the given letter.
 * @param {string} letter
 * @return {0 | 1}
 */
const lastBitFromLetter = letter => letter.charCodeAt(0) & 0x1

// Set the message according to the last bit
document.getElementById('message').textContent =
  lastBitFromLetter(getLetter(LENGTH, DEFAULT_ANSWER, QUESTION)) === 0
    ? 'False'
    : 'True'

Roadie fucked around with this message at 21:08 on Oct 8, 2017

Ranzear fucked around with this message at 18:22 on Oct 9, 2017

Knifegrab fucked around with this message at 19:39 on Oct 9, 2017

MrMoo fucked around with this message at 20:27 on Oct 9, 2017

ROFLburger fucked around with this message at 21:43 on Oct 9, 2017