A blog and podcast series by Bart Busschots & Allison Sheridan.
Using a loop of your choice, print the 12 times tables from 12 times 1 up to and including 12 times 12.
Solution Challenge 1
Challenge 2 – The Fibonacci Series
Write code to print out the Fibonacci series of numbers, stopping after the numbers go above 1,000,000 (you may print one number that is above 1,000,000, but no more).
The first two numbers in the series are 0 and 1. After that, the next number in the series is the sum of the previous two numbers.
Build up your solution in the following way:
Create an array named fibonacci with two initial values – 0, and 1.
Write a while loop that will keep going until the value of the last element of the fibonacci array is greater than 1,000,000. Inside the while loop, do the following:
Calculate the next Fibonacci number by adding the last two elements in the fibonacci array together.
Add this new value to the end of the fibonacci array.
Print the Fibonacci series, one element per line, by converting the fibonacci array into a string separated by newline characters.
Solution Challenge 2
Challenge 3 – FizzBuzz
This is a total cliché, and very common as an interview question. It tests if a programmer understands programming basics like loops and conditionals.
Write a program that prints the numbers from 1 to 100. But for multiples of three, print “Fizz” instead of the number. For the multiples of five, print “Buzz”. For numbers which are multiples of both three and five, print “FizzBuzz”.
Solution Challenge 3
Challenge 4 – Factorial
Write a function to calculate the factorial of an arbitrary number. Name the function factorial. It’s only possible to calculate the factorial of a whole number greater than or equal to zero. If an invalid input is passed, return NaN.
As a reminder, the factorial of 0 is 1, and the factorial of any positive number, n, is defined as n times the factorial of n - 1.
You can write your solution either using a loop of your choice or using recursion.
Test your function by calculating the factorial of the inputs in the PBS playground. If no inputs are set, print a message telling the user to enter numbers into the inputs.
Define a constructor function for your prototype (it must be named the same as the prototype we are building, i.e. ComplexNumber).
For now, the constructor will not take any arguments.
In the constructor, Initialise a key named _real to the value 0.
Also Initialise a key named _imaginary to the value 0.
Partial Solution Challenge 5.1
Add a so-called accessor function to the prototype to get or set the real part of the complex number. Name the function real.
If no arguments are passed, the function should return the current value of the _real key.
If there is a first argument, make sure it’s a number. If it’s not, throw an error. If it is, set it as the value of the _real key, and return a reference to the current object (i.e. this). (This will enable a technique known as function chaining, which we’ll see in action shortly.)
Partial Solution Challenge 5.2
Create a similar accessor function for the imaginary part of the complex number, and name it imaginary.
Partial Solution Challenge 5.3
Add a function to the prototype named toString. This function should return a string representation of the complex number. The rendering should adhere to the following rules:
In the general case, where both real and imaginary parts are non-zero, return a string of the following form: '(2 + 3i)'. If the imaginary number is negative, change the + to a -.
If the imaginary part is exactly 1, just show it as i.
If either of the parts are equal to zero, omit the parentheses.
If the real and imaginary parts are both zero, just return the string '0'.
If only the imaginary part is zero, return just the real part as a string.
If only the real part is zero, return just the imaginary part as a string followed by the letter i.
Partial Solution Challenge 5.4
Test what you have so far with the following code:
//// === Test the toString() and Accessor functions ===//// create a complex number, set its values, and print itvarcn1=newComplexNumber();// construct a ComplexNumbr objectcn1.real(2);// set the real part to 2cn1.imaginary(3);// set the imaginary part to 3pbs.say(cn1.toString());// print it// create a second complex number, using 'function chianing' to do it all at once// NOTE: function chaining is only possible becuase both accessor functions return// the special value this when they are used as setters.varcn2=(newComplexNumber()).real(2).imaginary(-4);pbs.say(cn2);// create some more complex number, but don't bother to save them, just print thempbs.say((newComplexNumber()).real(-5.5).imaginary(1));pbs.say((newComplexNumber()).real(7).imaginary(-1));pbs.say((newComplexNumber()).real(2).imaginary(-6));pbs.say((newComplexNumber()).real(-3));pbs.say((newComplexNumber()).real(21));pbs.say((newComplexNumber()).imaginary(-1));pbs.say((newComplexNumber()).imaginary(1));pbs.say((newComplexNumber()).imaginary(4.7));
Add a function named parse to the ComplexNumber prototype to update the value stored in the calling complex number object. This function should allow the new value be specified in a number of different ways. The following should all work:
Two numbers as arguments – first the real part, then the imaginary part.
An array of two numbers as a single argument – the first element in the array being the real part, the second the imaginary part.
A string of the form (a + bi) or (a - bi) where a is a positive or negative number, and b is a positive number.
An object with the prototype ComplexNumber.
Partial Solution Challenge 5.6
Test the parse function you just created with the following code:
//// === Test the Parse() function ===//varcn3=newComplexNumber();// construct a ComplexNumbr objectpbs.say(cn3.toString());// test the two-number formcn3.parse(2,4);pbs.say(cn3.toString());// test the one array formcn3.parse([-3,5.5]);pbs.say(cn3.toString());// test the one string formcn3.parse("(2 + 6i)");pbs.say(cn3.toString());cn3.parse("(2 - 6i)");pbs.say(cn3.toString());cn3.parse("(-2.76 + 6.2i)");pbs.say(cn3.toString());// test the one complex number object formvarcn4=(newComplexNumber()).real(3).imaginary(4);cn3.parse(cn4);pbs.say(cn3.toString());
Update your constructor so that it can accept the same arguments as the .parse() function. Do not copy and paste the code. Instead, update the constructor function to check if there are one or two arguments. If there are, call the parse function with the appropriate arguments.
Partial Solution Challenge 5.8
Test your updated constructor with the following code:
//// === Test the Updated Constructor ===//// test the two-number formpbs.say((newComplexNumber(1,2)).toString());// test the one array formpbs.say((newComplexNumber([2,3])).toString());// test the one string formpbs.say((newComplexNumber("(2 - 6i)")).toString());// test the one complex number object formvarcn5=newComplexNumber(-2,-4);pbs.say((newComplexNumber(cn5)).toString());
Add a function named add to the ComplexNumber prototype which accepts one argument, a complex number object, and adds it to the object the function is called on. Note that you add two complex numbers by adding the real parts together, and adding the imaginary parts together.
Partial Solution Challenge 5.10
In a similar vain, add function named subtract to the ComplexNumber prototype. You subtract complex numbers by subtracting the real and imaginary parts.
Partial Solution Challenge 5.11
Add a function named multiplyBy to the ComplexNumber prototype. The rule for multiplying complex numbers is, appropriately enough, quite complex. It can be summed up by the following rule:
(a+bi) x (c+di) = (ac−bd) + (ad+bc)i
Partial Solution Challenge 5.12
Add a function named conjugateOf to the ComplexNumber prototype. This function should return a new ComplexNumber object with the sign of the imaginary part flipped. I.e. 2 + 3i becomes 2 - 3i and vice-versa.
Partial Solution Challenge 5.13
Test your arithmetic functions with the following code:
//// === Test the Arithmentic Functions ===//// create a complex number to manipulatevarmyCN=newComplexNumber(1,2);pbs.say(myCN);// add 4 + 2i to our numbermyCN.add(newComplexNumber(4,2));pbs.say(myCN);// subtract 2 + i from our numbermyCN.subtract(newComplexNumber(2,1));pbs.say(myCN);// set the value to 3 + 2imyCN.parse(3,2);// multiply by 1 + 7imyCN.multiplyBy(newComplexNumber(1,7));pbs.say(myCN.toString());// should be -11 + 23i// get the conjugatemyCN=myCN.conjugateOf();pbs.say(myCN.toString());// get the conjugate againmyCN=myCN.conjugateOf();pbs.say(myCN.toString());